diff --git a/Android.mk b/Android.mk
index 3d52f44..3a3169c 100644
--- a/Android.mk
+++ b/Android.mk
@@ -542,8 +542,7 @@
 framework_docs_LOCAL_ADDITIONAL_DEPENDENCIES := \
     frameworks/base/docs/knowntags.txt
 
-sample_dir := development/samples/browseable
-new_sample_dir := developers/samples/android
+samples_dir := development/samples/browseable
 
 # Whitelist of valid groups, used for default TOC grouping. Each sample must
 # belong to one (and only one) group. Assign samples to groups by setting
@@ -558,161 +557,6 @@
                  -samplegroup UI \
                  -samplegroup Views
 
-# the list here should match the list of samples included in the sdk samples package
-# (see development/build/sdk.atree)
-# remove htmlified samples for now -- samples are still available through the SDK
-web_docs_sample_code_flags := \
-		-hdf android.hasSamples 1 \
-		-samplecode $(sample_dir)/BasicAccessibility \
- 		            samples/BasicAccessibility "" \
-		-samplecode $(sample_dir)/HorizontalPaging \
- 		            samples/HorizontalPaging "" \
-		-samplecode $(sample_dir)/ShareActionProvider \
- 		            samples/ShareActionProvider "" \
-		-samplecode $(sample_dir)/Styled \
- 		            samples/Styled "" \
-		-samplecode $(sample_dir)/BasicAndroidKeyStore \
- 		            samples/BasicAndroidKeyStore "" \
-		-samplecode $(sample_dir)/Basic \
- 		            samples/Basic "" \
-		-samplecode $(sample_dir)/ImmersiveMode \
- 		            samples/ImmersiveMode "" \
-		-samplecode $(sample_dir)/repeatingAlarm \
- 		            samples/repeatingAlarm "" \
-		-samplecode $(sample_dir)/TextLinkify \
- 		            samples/TextLinkify "" \
-		-samplecode $(sample_dir)/BasicMediaRouter \
- 		            samples/BasicMediaRouter "" \
-		-samplecode $(sample_dir)/BasicMultitouch \
- 		            samples/BasicMultitouch "" \
-		-samplecode $(sample_dir)/TextSwitcher \
- 		            samples/TextSwitcher "" \
-		-samplecode $(sample_dir)/ActivityInstrumentation \
- 		            samples/ActivityInstrumentation "" \
-		-samplecode $(sample_dir)/BorderlessButtons \
- 		            samples/BorderlessButtons "" \
-		-samplecode $(sample_dir)/BasicNotifications \
- 		            samples/BasicNotifications "" \
-		-samplecode $(sample_dir)/AdvancedImmersiveMode \
- 		            samples/AdvancedImmersiveMode "" \
-		-samplecode $(sample_dir)/BluetoothLeGatt \
- 		            samples/BluetoothLeGatt "" \
-		-samplecode $(sample_dir)/NetworkConnect \
- 		            samples/NetworkConnect "" \
-		-samplecode $(sample_dir)/BasicNetworking \
- 		            samples/BasicNetworking "" \
-		-samplecode $(sample_dir)/BasicMediaDecoder \
- 		            samples/BasicMediaDecoder "" \
-		-samplecode $(sample_dir)/BasicImmersiveMode \
- 		            samples/BasicImmersiveMode "" \
-		-samplecode $(sample_dir)/CustomChoiceList \
- 		            samples/CustomChoiceList "" \
-		-samplecode $(sample_dir)/BasicContactables \
- 		            samples/BasicContactables "" \
-		-samplecode $(sample_dir)/BasicGestureDetect \
- 		            samples/BasicGestureDetect "" \
-		-samplecode $(sample_dir)/DoneBar \
- 		            samples/DoneBar "" \
-		-samplecode $(sample_dir)/ListPopupMenu \
- 		            samples/ListPopupMenu "" \
-		-samplecode $(sample_dir)/AppRestrictions \
- 		            samples/AppRestrictions "" \
-		-samplecode $(sample_dir)/CustomNotifications \
- 		            samples/CustomNotifications "" \
-		-samplecode $(sample_dir)/BasicSyncAdapter \
- 		            samples/BasicSyncAdapter "" \
-		-samplecode $(sample_dir)/StorageClient \
- 		            samples/StorageClient "" \
-		-samplecode $(sample_dir)/StorageProvider \
- 		            samples/StorageProvider ""
-#       -samplecode $(sample_dir)/AndroidBeamDemo \
-# 		            samples/AndroidBeamDemo "Android Beam Demo" \
-# 		-samplecode $(sample_dir)/ApiDemos \
-# 		            samples/ApiDemos "API Demos" \
-# 		-samplecode $(sample_dir)/Support4Demos \
-# 		            samples/Support4Demos "API 4+ Support Demos" \
-# 		-samplecode $(sample_dir)/Support13Demos \
-# 		            samples/Support13Demos "API 13+ Support Demos" \
-# 		-samplecode $(sample_dir)/BackupRestore \
-# 		            samples/BackupRestore "Backup and Restore" \
-#		-samplecode $(sample_dir)/BluetoothChat \
-# 		            samples/BluetoothChat "Bluetooth Chat" \
-# 		-samplecode $(sample_dir)/BusinessCard \
-# 		            samples/BusinessCard "Business Card" \
-# 		-samplecode $(sample_dir)/ContactManager \
-# 		            samples/ContactManager "Contact Manager" \
-# 		-samplecode $(sample_dir)/CubeLiveWallpaper \
-# 		            samples/CubeLiveWallpaper "Cube Live Wallpaper" \
-# 		-samplecode $(sample_dir)/Home \
-# 		            samples/Home "Home" \
-# 		-samplecode $(sample_dir)/HoneycombGallery \
-# 		            samples/HoneycombGallery "Honeycomb Gallery" \
-# 		-samplecode $(sample_dir)/JetBoy \
-# 		            samples/JetBoy "JetBoy" \
-# 		-samplecode $(sample_dir)/KeyChainDemo \
-# 		            samples/KeyChainDemo "KeyChain Demo" \
-# 		-samplecode $(sample_dir)/LunarLander \
-# 		            samples/LunarLander "Lunar Lander" \
-# 		-samplecode $(sample_dir)/training/ads-and-ux \
-# 		            samples/training/ads-and-ux "Mobile Advertisement Integration" \
-# 		-samplecode $(sample_dir)/MultiResolution \
-# 		            samples/MultiResolution "Multiple Resolutions" \
-# 		-samplecode $(sample_dir)/training/multiscreen/newsreader \
-# 		            samples/newsreader "News Reader" \
-# 		-samplecode $(sample_dir)/NotePad \
-# 		            samples/NotePad "Note Pad" \
-# 		-samplecode $(sample_dir)/SpellChecker/SampleSpellCheckerService \
-# 		            samples/SpellChecker/SampleSpellCheckerService "Spell Checker Service" \
-# 		-samplecode $(sample_dir)/SpellChecker/HelloSpellChecker \
-# 		            samples/SpellChecker/HelloSpellChecker "Spell Checker Client" \
-# 		-samplecode $(sample_dir)/SampleSyncAdapter \
-# 		            samples/SampleSyncAdapter "Sample Sync Adapter" \
-# 		-samplecode $(sample_dir)/RandomMusicPlayer \
-# 		            samples/RandomMusicPlayer "Random Music Player" \
-# 		-samplecode $(sample_dir)/RenderScript \
-# 		            samples/RenderScript "RenderScript" \
-# 		-samplecode $(sample_dir)/SearchableDictionary \
-# 		            samples/SearchableDictionary "Searchable Dictionary v2" \
-# 		-samplecode $(sample_dir)/SipDemo \
-# 		            samples/SipDemo "SIP Demo" \
-# 		-samplecode $(sample_dir)/Snake \
-# 		            samples/Snake "Snake" \
-# 		-samplecode $(sample_dir)/SoftKeyboard \
-# 		            samples/SoftKeyboard "Soft Keyboard" \
-# 		-samplecode $(sample_dir)/Spinner  \
-# 		            samples/Spinner "Spinner" \
-# 		-samplecode $(sample_dir)/SpinnerTest \
-# 		            samples/SpinnerTest "SpinnerTest" \
-# 		-samplecode $(sample_dir)/StackWidget \
-# 		            samples/StackWidget "StackView Widget" \
-# 		-samplecode $(sample_dir)/TicTacToeLib  \
-# 		            samples/TicTacToeLib "TicTacToeLib" \
-# 		-samplecode $(sample_dir)/TicTacToeMain \
-# 		            samples/TicTacToeMain "TicTacToeMain" \
-# 		-samplecode $(sample_dir)/ToyVpn \
-# 		            samples/ToyVpn "Toy VPN Client" \
-# 		-samplecode $(sample_dir)/USB \
-# 		            samples/USB "USB" \
-# 		-samplecode $(sample_dir)/WeatherListWidget \
-# 		            samples/WeatherListWidget "Weather List Widget" \
-# 		-samplecode $(sample_dir)/WiFiDirectDemo \
-#                   samples/WiFiDirectDemo "Wi-Fi Direct Demo" \
-# 		-samplecode $(sample_dir)/Wiktionary \
-# 		            samples/Wiktionary "Wiktionary" \
-# 		-samplecode $(sample_dir)/WiktionarySimple \
-# 		            samples/WiktionarySimple "Wiktionary (Simplified)" \
-# 		-samplecode $(sample_dir)/VoiceRecognitionService \
-# 		            samples/VoiceRecognitionService "Voice Recognition Service" \
-# 		-samplecode $(sample_dir)/VoicemailProviderDemo \
-# 		            samples/VoicemailProviderDemo "Voicemail Provider Demo" \
-# 		-samplecode $(sample_dir)/XmlAdapters \
-# 		            samples/XmlAdapters "XML Adapters" \
-# 		-samplecode $(sample_dir)/TtsEngine \
-# 		            samples/TtsEngine "Text To Speech Engine" \
-# 		-samplecode $(sample_dir)/training/device-management-policy \
-# 		            samples/training/device-management-policy "Device Management Policy"
-
-
 ## SDK version identifiers used in the published docs
   # major[.minor] version for current SDK. (full releases only)
 framework_docs_SDK_VERSION:=4.4
@@ -722,7 +566,7 @@
 framework_docs_LOCAL_DROIDDOC_OPTIONS += \
 		-hdf sdk.version $(framework_docs_SDK_VERSION) \
 		-hdf sdk.rel.id $(framework_docs_SDK_REL_ID) \
-		-hdf sdk.preview 0 \
+		-hdf sdk.preview 0
 
 # ====  the api stubs and current.xml ===========================
 include $(CLEAR_VARS)
@@ -808,8 +652,6 @@
 		-todo $(OUT_DOCS)/$(LOCAL_MODULE)-docs-todo.html \
 		-sdkvalues $(OUT_DOCS) \
 		-hdf android.whichdoc offline
-#		$(web_docs_sample_code_flags)
-
 
 LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:=build/tools/droiddoc/templates-sdk
 
@@ -836,7 +678,7 @@
 LOCAL_DROIDDOC_HTML_DIR:=$(framework_docs_LOCAL_DROIDDOC_HTML_DIR)
 LOCAL_ADDITIONAL_JAVA_DIR:=$(framework_docs_LOCAL_ADDITIONAL_JAVA_DIR)
 LOCAL_ADDITIONAL_DEPENDENCIES:=$(framework_docs_LOCAL_ADDITIONAL_DEPENDENCIES)
-LOCAL_ADDITIONAL_HTML_DIR:=docs/html-intl /intl/
+LOCAL_ADDITIONAL_HTML_DIR:=docs/html-intl /
 
 LOCAL_MODULE := online-sdk
 
@@ -845,7 +687,8 @@
 		-toroot / \
 		-hdf android.whichdoc online \
 		$(sample_groups) \
-		$(web_docs_sample_code_flags)
+		-hdf android.hasSamples true \
+		-samplesdir $(samples_dir)
 
 LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:=build/tools/droiddoc/templates-sdk
 
@@ -863,7 +706,7 @@
 LOCAL_ADDITIONAL_JAVA_DIR:=$(framework_docs_LOCAL_ADDITIONAL_JAVA_DIR)
 LOCAL_ADDITIONAL_DEPENDENCIES:=$(framework_docs_LOCAL_ADDITIONAL_DEPENDENCIES)
 # specify a second html input dir and an output path relative to OUT_DIR)
-LOCAL_ADDITIONAL_HTML_DIR:=docs/html-intl /
+LOCAL_ADDITIONAL_HTML_DIR:=docs/html-intl/intl /
 
 LOCAL_MODULE := ds
 
@@ -873,7 +716,6 @@
 		-toroot / \
 		-hdf android.whichdoc online \
 		-hdf devsite true
-#		$(web_docs_sample_code_flags)
 
 LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:=build/tools/droiddoc/templates-sdk
 
diff --git a/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java b/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
index 2666b41..db3d8bb 100644
--- a/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
+++ b/cmds/bmgr/src/com/android/commands/bmgr/Bmgr.java
@@ -187,6 +187,12 @@
     }
 
     private void doWipe() {
+        String transport = nextArg();
+        if (transport == null) {
+            showUsage();
+            return;
+        }
+
         String pkg = nextArg();
         if (pkg == null) {
             showUsage();
@@ -194,8 +200,8 @@
         }
 
         try {
-            mBmgr.clearBackupData(pkg);
-            System.out.println("Wiped backup data for " + pkg);
+            mBmgr.clearBackupData(transport, pkg);
+            System.out.println("Wiped backup data for " + pkg + " on " + transport);
         } catch (RemoteException e) {
             System.err.println(e.toString());
             System.err.println(BMGR_NOT_RUNNING_ERR);
@@ -446,7 +452,7 @@
         System.err.println("       bmgr restore TOKEN PACKAGE...");
         System.err.println("       bmgr restore PACKAGE");
         System.err.println("       bmgr run");
-        System.err.println("       bmgr wipe PACKAGE");
+        System.err.println("       bmgr wipe TRANSPORT PACKAGE");
         System.err.println("");
         System.err.println("The 'backup' command schedules a backup pass for the named package.");
         System.err.println("Note that the backup pass will effectively be a no-op if the package");
@@ -462,8 +468,8 @@
         System.err.println("");
         System.err.println("The 'list transports' command reports the names of the backup transports");
         System.err.println("currently available on the device.  These names can be passed as arguments");
-        System.err.println("to the 'transport' command.  The currently selected transport is indicated");
-        System.err.println("with a '*' character.");
+        System.err.println("to the 'transport' and 'wipe' commands.  The currently selected transport");
+        System.err.println("is indicated with a '*' character.");
         System.err.println("");
         System.err.println("The 'list sets' command reports the token and name of each restore set");
         System.err.println("available to the device via the current transport.");
@@ -491,7 +497,8 @@
         System.err.println("data changes.");
         System.err.println("");
         System.err.println("The 'wipe' command causes all backed-up data for the given package to be");
-        System.err.println("erased from the current transport's storage.  The next backup operation");
+        System.err.println("erased from the given transport's storage.  The next backup operation");
         System.err.println("that the given application performs will rewrite its entire data set.");
+        System.err.println("Transport names to use here are those reported by 'list transports'.");
     }
 }
diff --git a/core/java/android/app/PendingIntent.java b/core/java/android/app/PendingIntent.java
index bdd0adb..f6e1f72 100644
--- a/core/java/android/app/PendingIntent.java
+++ b/core/java/android/app/PendingIntent.java
@@ -87,23 +87,25 @@
     private final IIntentSender mTarget;
 
     /**
-     * Flag for use with {@link #getActivity}, {@link #getBroadcast}, and
-     * {@link #getService}: this
-     * PendingIntent can only be used once.  If set, after
+     * Flag indicating that this PendingIntent can be used only once.
+     * For use with {@link #getActivity}, {@link #getBroadcast}, and
+     * {@link #getService}. <p>If set, after
      * {@link #send()} is called on it, it will be automatically
      * canceled for you and any future attempt to send through it will fail.
      */
     public static final int FLAG_ONE_SHOT = 1<<30;
     /**
-     * Flag for use with {@link #getActivity}, {@link #getBroadcast}, and
-     * {@link #getService}: if the described PendingIntent does not already
-     * exist, then simply return null instead of creating it.
+     * Flag indicating that if the described PendingIntent already
+     * exists, then simply return null instead of creating it.
+     * For use with {@link #getActivity}, {@link #getBroadcast}, and
+     * {@link #getService}.
      */
     public static final int FLAG_NO_CREATE = 1<<29;
     /**
-     * Flag for use with {@link #getActivity}, {@link #getBroadcast}, and
-     * {@link #getService}: if the described PendingIntent already exists,
-     * the current one is canceled before generating a new one.  You can use
+     * Flag indicating that if the described PendingIntent already exists,
+     * the current one should be canceled before generating a new one.
+     * For use with {@link #getActivity}, {@link #getBroadcast}, and
+     * {@link #getService}. <p>You can use
      * this to retrieve a new PendingIntent when you are only changing the
      * extra data in the Intent; by canceling the previous pending intent,
      * this ensures that only entities given the new data will be able to
@@ -112,10 +114,10 @@
      */
     public static final int FLAG_CANCEL_CURRENT = 1<<28;
     /**
-     * Flag for use with {@link #getActivity}, {@link #getBroadcast}, and
-     * {@link #getService}: if the described PendingIntent already exists,
-     * then keep it but its replace its extra data with what is in this new
-     * Intent.  This can be used if you are creating intents where only the
+     * Flag indicating that if the described PendingIntent already exists,
+     * then keep it but replace its extra data with what is in this new
+     * Intent. For use with {@link #getActivity}, {@link #getBroadcast}, and
+     * {@link #getService}. <p>This can be used if you are creating intents where only the
      * extras change, and don't care that any entities that received your
      * previous PendingIntent will be able to launch it with your new
      * extras even if they are not explicitly given to it.
diff --git a/core/java/android/app/backup/IBackupManager.aidl b/core/java/android/app/backup/IBackupManager.aidl
index bb4f5f1..12ee3b6 100644
--- a/core/java/android/app/backup/IBackupManager.aidl
+++ b/core/java/android/app/backup/IBackupManager.aidl
@@ -43,14 +43,14 @@
     void dataChanged(String packageName);
 
     /**
-     * Erase all backed-up data for the given package from the storage
+     * Erase all backed-up data for the given package from the given storage
      * destination.
      *
      * Any application can invoke this method for its own package, but
      * only callers who hold the android.permission.BACKUP permission
      * may invoke it for arbitrary packages.
      */
-    void clearBackupData(String packageName);
+    void clearBackupData(String transportName, String packageName);
 
     /**
      * Notifies the Backup Manager Service that an agent has become available.  This
diff --git a/core/java/android/bluetooth/package.html b/core/java/android/bluetooth/package.html
index 200a21b..d9ca4f1 100644
--- a/core/java/android/bluetooth/package.html
+++ b/core/java/android/bluetooth/package.html
@@ -8,17 +8,19 @@
 <a href="{@docRoot}guide/topics/connectivity/bluetooth.html">Bluetooth</a> guide.
 For more information about Bluetooth Low Energy, see the
 <a href="{@docRoot}guide/topics/connectivity/bluetooth-le.html">
-Bluetooth Low Energy</a> guide.</p>
+Bluetooth Low Energy</a> (BLE) guide.</p>
 {@more}
 
 <p>The Bluetooth APIs let applications:</p>
 <ul>
-  <li>Scan for other Bluetooth devices (including Bluetooth Low Energy
-    devices)</li>
-  <li>Query the local Bluetooth adapter for paired Bluetooth devices</li>
-  <li>Establish RFCOMM channels/sockets</li>
-  <li>Connect to specified sockets on other devices</li>
-  <li>Transfer data to and from other devices</li>
+  <li>Scan for other Bluetooth devices (including BLE devices).</li>
+  <li>Query the local Bluetooth adapter for paired Bluetooth devices.</li>
+  <li>Establish RFCOMM channels/sockets.</li>
+  <li>Connect to specified sockets on other devices.</li>
+  <li>Transfer data to and from other devices.</li>
+  <li>Communicate with BLE devices, such as proximity sensors, heart rate
+    monitors, fitness devices, and so on.</li>
+  <li>Act as a GATT client or a GATT server (BLE).</li>
 </ul>
 
 <p>
diff --git a/core/java/android/content/Intent.java b/core/java/android/content/Intent.java
index a289649..a047668 100644
--- a/core/java/android/content/Intent.java
+++ b/core/java/android/content/Intent.java
@@ -4415,7 +4415,7 @@
      * Return the {@link ClipData} associated with this Intent.  If there is
      * none, returns null.  See {@link #setClipData} for more information.
      *
-     * @see #setClipData;
+     * @see #setClipData
      */
     public ClipData getClipData() {
         return mClipData;
@@ -7153,8 +7153,8 @@
      *
      * @param type MIME data type to normalize
      * @return normalized MIME data type, or null if the input was null
-     * @see {@link #setType}
-     * @see {@link #setTypeAndNormalize}
+     * @see #setType
+     * @see #setTypeAndNormalize
      */
     public static String normalizeMimeType(String type) {
         if (type == null) {
diff --git a/core/java/android/hardware/SensorManager.java b/core/java/android/hardware/SensorManager.java
index b931313..8c23129 100644
--- a/core/java/android/hardware/SensorManager.java
+++ b/core/java/android/hardware/SensorManager.java
@@ -1056,8 +1056,8 @@
      *        is mapped.
      *
      * @param outR
-     *        the transformed rotation matrix. inR and outR can be the same
-     *        array, but it is not recommended for performance reason.
+     *        the transformed rotation matrix. inR and outR should not be the same
+     *        array.
      *
      * @return <code>true</code> on success. <code>false</code> if the input
      *         parameters are incorrect, for instance if X and Y define the same
diff --git a/core/java/android/hardware/display/DisplayManager.java b/core/java/android/hardware/display/DisplayManager.java
index d5208d9..093e0e9 100644
--- a/core/java/android/hardware/display/DisplayManager.java
+++ b/core/java/android/hardware/display/DisplayManager.java
@@ -297,16 +297,31 @@
     }
 
     /**
-     * Initiates a fresh scan of availble Wifi displays.
+     * Starts scanning for available Wifi displays.
      * The results are sent as a {@link #ACTION_WIFI_DISPLAY_STATUS_CHANGED} broadcast.
      * <p>
+     * Calls to this method nest and must be matched by an equal number of calls to
+     * {@link #stopWifiDisplayScan()}.
+     * </p><p>
+     * Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
+     * </p>
+     *
+     * @hide
+     */
+    public void startWifiDisplayScan() {
+        mGlobal.startWifiDisplayScan();
+    }
+
+    /**
+     * Stops scanning for available Wifi displays.
+     * <p>
      * Requires {@link android.Manifest.permission#CONFIGURE_WIFI_DISPLAY}.
      * </p>
      *
      * @hide
      */
-    public void scanWifiDisplays() {
-        mGlobal.scanWifiDisplays();
+    public void stopWifiDisplayScan() {
+        mGlobal.stopWifiDisplayScan();
     }
 
     /**
diff --git a/core/java/android/hardware/display/DisplayManagerGlobal.java b/core/java/android/hardware/display/DisplayManagerGlobal.java
index 936a086..3417430 100644
--- a/core/java/android/hardware/display/DisplayManagerGlobal.java
+++ b/core/java/android/hardware/display/DisplayManagerGlobal.java
@@ -72,6 +72,8 @@
     private final SparseArray<DisplayInfo> mDisplayInfoCache = new SparseArray<DisplayInfo>();
     private int[] mDisplayIdCache;
 
+    private int mWifiDisplayScanNestCount;
+
     private DisplayManagerGlobal(IDisplayManager dm) {
         mDm = dm;
     }
@@ -267,11 +269,32 @@
         }
     }
 
-    public void scanWifiDisplays() {
-        try {
-            mDm.scanWifiDisplays();
-        } catch (RemoteException ex) {
-            Log.e(TAG, "Failed to scan for Wifi displays.", ex);
+    public void startWifiDisplayScan() {
+        synchronized (mLock) {
+            if (mWifiDisplayScanNestCount++ == 0) {
+                registerCallbackIfNeededLocked();
+                try {
+                    mDm.startWifiDisplayScan();
+                } catch (RemoteException ex) {
+                    Log.e(TAG, "Failed to scan for Wifi displays.", ex);
+                }
+            }
+        }
+    }
+
+    public void stopWifiDisplayScan() {
+        synchronized (mLock) {
+            if (--mWifiDisplayScanNestCount == 0) {
+                try {
+                    mDm.stopWifiDisplayScan();
+                } catch (RemoteException ex) {
+                    Log.e(TAG, "Failed to scan for Wifi displays.", ex);
+                }
+            } else if (mWifiDisplayScanNestCount < 0) {
+                Log.wtf(TAG, "Wifi display scan nest count became negative: "
+                        + mWifiDisplayScanNestCount);
+                mWifiDisplayScanNestCount = 0;
+            }
         }
     }
 
diff --git a/core/java/android/hardware/display/IDisplayManager.aidl b/core/java/android/hardware/display/IDisplayManager.aidl
index 6b2c887..68eb13f 100644
--- a/core/java/android/hardware/display/IDisplayManager.aidl
+++ b/core/java/android/hardware/display/IDisplayManager.aidl
@@ -29,11 +29,14 @@
 
     void registerCallback(in IDisplayManagerCallback callback);
 
-    // No permissions required.
-    void scanWifiDisplays();
+    // Requires CONFIGURE_WIFI_DISPLAY permission.
+    // The process must have previously registered a callback.
+    void startWifiDisplayScan();
 
-    // Requires CONFIGURE_WIFI_DISPLAY permission to connect to an unknown device.
-    // No permissions required to connect to a known device.
+    // Requires CONFIGURE_WIFI_DISPLAY permission.
+    void stopWifiDisplayScan();
+
+    // Requires CONFIGURE_WIFI_DISPLAY permission.
     void connectWifiDisplay(String address);
 
     // No permissions required.
@@ -45,6 +48,12 @@
     // Requires CONFIGURE_WIFI_DISPLAY permission.
     void forgetWifiDisplay(String address);
 
+    // Requires CONFIGURE_WIFI_DISPLAY permission.
+    void pauseWifiDisplay();
+
+    // Requires CONFIGURE_WIFI_DISPLAY permission.
+    void resumeWifiDisplay();
+
     // No permissions required.
     WifiDisplayStatus getWifiDisplayStatus();
 
@@ -55,10 +64,4 @@
 
     // No permissions required but must be same Uid as the creator.
     void releaseVirtualDisplay(in IBinder token);
-
-    // Requires CONFIGURE_WIFI_DISPLAY permission.
-    void pauseWifiDisplay();
-
-    // Requires CONFIGURE_WIFI_DISPLAY permission.
-    void resumeWifiDisplay();
 }
diff --git a/core/java/android/os/Build.java b/core/java/android/os/Build.java
index bc51a60..22e1476 100644
--- a/core/java/android/os/Build.java
+++ b/core/java/android/os/Build.java
@@ -49,7 +49,7 @@
     /** The manufacturer of the product/hardware. */
     public static final String MANUFACTURER = getString("ro.product.manufacturer");
 
-    /** The brand (e.g., carrier) the software is customized for, if any. */
+    /** The consumer-visible brand with which the product/hardware will be associated, if any. */
     public static final String BRAND = getString("ro.product.brand");
 
     /** The end-user-visible name for the end product. */
diff --git a/core/java/android/preference/PreferenceActivity.java b/core/java/android/preference/PreferenceActivity.java
index 7ddfa87..2ab5a91 100644
--- a/core/java/android/preference/PreferenceActivity.java
+++ b/core/java/android/preference/PreferenceActivity.java
@@ -33,6 +33,7 @@
 import android.os.Parcelable;
 import android.text.TextUtils;
 import android.util.AttributeSet;
+import android.util.Log;
 import android.util.TypedValue;
 import android.util.Xml;
 import android.view.LayoutInflater;
@@ -124,6 +125,8 @@
         PreferenceManager.OnPreferenceTreeClickListener,
         PreferenceFragment.OnPreferenceStartFragmentCallback {
 
+    private static final String TAG = "PreferenceActivity";
+
     // Constants for state save/restore
     private static final String HEADERS_TAG = ":android:headers";
     private static final String CUR_HEADER_TAG = ":android:cur_header";
@@ -521,9 +524,7 @@
         int initialTitle = getIntent().getIntExtra(EXTRA_SHOW_FRAGMENT_TITLE, 0);
         int initialShortTitle = getIntent().getIntExtra(EXTRA_SHOW_FRAGMENT_SHORT_TITLE, 0);
 
-        // Restore from headers only if they are supported which
-        // is in multi-pane mode.
-        if (savedInstanceState != null && !mSinglePane) {
+        if (savedInstanceState != null) {
             // We are restarting from a previous saved state; used that to
             // initialize, instead of starting fresh.
             ArrayList<Header> headers = savedInstanceState.getParcelableArrayList(HEADERS_TAG);
diff --git a/core/java/android/provider/DocumentsContract.java b/core/java/android/provider/DocumentsContract.java
index 86d3cf8..f0520b5 100644
--- a/core/java/android/provider/DocumentsContract.java
+++ b/core/java/android/provider/DocumentsContract.java
@@ -257,8 +257,6 @@
          * {@link #MIME_TYPE_DIR}.
          *
          * @see #COLUMN_FLAGS
-         * @see DocumentsContract#createDocument(ContentResolver, Uri, String,
-         *      String)
          * @see DocumentsProvider#createDocument(String, String, String)
          */
         public static final int FLAG_DIR_SUPPORTS_CREATE = 1 << 3;
diff --git a/core/java/android/util/LongSparseArray.java b/core/java/android/util/LongSparseArray.java
index d6e116f..dab853a 100644
--- a/core/java/android/util/LongSparseArray.java
+++ b/core/java/android/util/LongSparseArray.java
@@ -44,7 +44,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  */
 public class LongSparseArray<E> implements Cloneable {
     private static final Object DELETED = new Object();
diff --git a/core/java/android/util/LongSparseLongArray.java b/core/java/android/util/LongSparseLongArray.java
index 87d868b..6654899 100644
--- a/core/java/android/util/LongSparseLongArray.java
+++ b/core/java/android/util/LongSparseLongArray.java
@@ -39,7 +39,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  *
  * @hide
  */
diff --git a/core/java/android/util/SparseArray.java b/core/java/android/util/SparseArray.java
index 6e168a8..46d9d45 100644
--- a/core/java/android/util/SparseArray.java
+++ b/core/java/android/util/SparseArray.java
@@ -44,7 +44,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  */
 public class SparseArray<E> implements Cloneable {
     private static final Object DELETED = new Object();
diff --git a/core/java/android/util/SparseBooleanArray.java b/core/java/android/util/SparseBooleanArray.java
index 68487e3..905dcb0 100644
--- a/core/java/android/util/SparseBooleanArray.java
+++ b/core/java/android/util/SparseBooleanArray.java
@@ -38,7 +38,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  */
 public class SparseBooleanArray implements Cloneable {
     /**
diff --git a/core/java/android/util/SparseIntArray.java b/core/java/android/util/SparseIntArray.java
index 0835cb0..4f5ca07 100644
--- a/core/java/android/util/SparseIntArray.java
+++ b/core/java/android/util/SparseIntArray.java
@@ -37,7 +37,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  */
 public class SparseIntArray implements Cloneable {
     private int[] mKeys;
diff --git a/core/java/android/util/SparseLongArray.java b/core/java/android/util/SparseLongArray.java
index 62c1c0d..39fc8a3 100644
--- a/core/java/android/util/SparseLongArray.java
+++ b/core/java/android/util/SparseLongArray.java
@@ -37,7 +37,7 @@
  * {@link #keyAt(int)} and {@link #valueAt(int)}. Iterating over the keys using
  * <code>keyAt(int)</code> with ascending values of the index will return the
  * keys in ascending order, or the values corresponding to the keys in ascending
- * order in the case of <code>valueAt(int)<code>.</p>
+ * order in the case of <code>valueAt(int)</code>.</p>
  */
 public class SparseLongArray implements Cloneable {
     private int[] mKeys;
diff --git a/core/java/android/widget/ShareActionProvider.java b/core/java/android/widget/ShareActionProvider.java
index 62afd2e..bdaaa01 100644
--- a/core/java/android/widget/ShareActionProvider.java
+++ b/core/java/android/widget/ShareActionProvider.java
@@ -266,7 +266,7 @@
      * Intent shareIntent = new Intent(Intent.ACTION_SEND);
      * shareIntent.setType("image/*");
      * Uri uri = Uri.fromFile(new File(getFilesDir(), "foo.jpg"));
-     * shareIntent.putExtra(Intent.EXTRA_STREAM, uri.toString());</pre>
+     * shareIntent.putExtra(Intent.EXTRA_STREAM, uri));</pre>
      *
      * @param shareIntent The share intent.
      *
diff --git a/core/res/res/drawable-hdpi/ic_media_route_disabled_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_disabled_holo_dark.png
index 458a2a6..b47d666 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_disabled_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_disabled_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_off_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_off_holo_dark.png
index c91faa9..13d803c 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_off_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_off_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_off_holo_light.png b/core/res/res/drawable-hdpi/ic_media_route_off_holo_light.png
index 14c9183..3ae436b 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_off_holo_light.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_off_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_dark.png
index b388d86..24824fc 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_light.png b/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_light.png
index 76c1323..af3819b 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_light.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_0_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_dark.png
index fd39f9d..83dc251 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_light.png b/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_light.png
index c74727a..8d9d592 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_light.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_1_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_dark.png
index 826c9ae..1310ec9 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_light.png b/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_light.png
index d0baec3..1705074 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_light.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_2_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_holo_dark.png b/core/res/res/drawable-hdpi/ic_media_route_on_holo_dark.png
index c60ff59..7027b88 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_holo_dark.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-hdpi/ic_media_route_on_holo_light.png b/core/res/res/drawable-hdpi/ic_media_route_on_holo_light.png
index 75552cc..7027b88 100644
--- a/core/res/res/drawable-hdpi/ic_media_route_on_holo_light.png
+++ b/core/res/res/drawable-hdpi/ic_media_route_on_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_off_holo_dark.png b/core/res/res/drawable-mdpi/ic_media_route_off_holo_dark.png
index 9d92648..6764598 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_off_holo_dark.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_off_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_off_holo_light.png b/core/res/res/drawable-mdpi/ic_media_route_off_holo_light.png
index 3e27fc8..94e0bb6 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_off_holo_light.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_off_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_dark.png b/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_dark.png
index 72b9e78..5ce2f20 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_dark.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_light.png b/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_light.png
index bd462a2..5105e90 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_light.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_0_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_dark.png b/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_dark.png
index 0a2cc89..68c06ed 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_dark.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_light.png b/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_light.png
index d162503..6e9b144 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_light.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_1_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_dark.png b/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_dark.png
index 997e32b..45dc56f3d 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_dark.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_light.png b/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_light.png
index d314967..46e743a 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_light.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_2_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_holo_dark.png b/core/res/res/drawable-mdpi/ic_media_route_on_holo_dark.png
index f15d7a9..e384691 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_holo_dark.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-mdpi/ic_media_route_on_holo_light.png b/core/res/res/drawable-mdpi/ic_media_route_on_holo_light.png
index 26d46f8..e384691 100644
--- a/core/res/res/drawable-mdpi/ic_media_route_on_holo_light.png
+++ b/core/res/res/drawable-mdpi/ic_media_route_on_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_dark.png
index 045eee0..1d48e12 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_light.png
index 6e14e29..2c8d1ec 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_disabled_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_off_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_off_holo_dark.png
index 121bbf6..00b2043 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_off_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_off_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_off_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_off_holo_light.png
index 468a0c3..ce1d939 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_off_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_off_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_dark.png
index 414a322..3064b46 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_light.png
index 6088a48..4316686 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_0_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_dark.png
index 363d7d4..25c4e31 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_light.png
index edf731e..8e32bd2 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_1_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_dark.png
index 85cba7b..aeaa78f 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_light.png
index e65ac31..85277fa 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_2_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_holo_dark.png b/core/res/res/drawable-xhdpi/ic_media_route_on_holo_dark.png
index d8e3e3a..b01dbe8 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_holo_dark.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xhdpi/ic_media_route_on_holo_light.png b/core/res/res/drawable-xhdpi/ic_media_route_on_holo_light.png
index 562dc9a..c19a2ad 100644
--- a/core/res/res/drawable-xhdpi/ic_media_route_on_holo_light.png
+++ b/core/res/res/drawable-xhdpi/ic_media_route_on_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_dark.png
index 178774c..7b0c383 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_light.png
index 2dc2092..efb624e 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_disabled_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_dark.png
index 592ee8c..5ee57e4 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_light.png
index f0549e2..6bc2e4a 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_off_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_dark.png
index 91268f5..c13af9c 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_light.png
index 9d5436f..744fb42 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_0_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_dark.png
index 8e77483..ca4d59c 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_light.png
index f396d22..fde5688a 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_1_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_dark.png
index 260bab4..b8715c3 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_light.png
index 2c9fb1d..668bb25 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_2_holo_light.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_dark.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_dark.png
index bdbd59c..7f54a62 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_dark.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_dark.png
Binary files differ
diff --git a/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_light.png b/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_light.png
index f5c33dd..2df924d 100644
--- a/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_light.png
+++ b/core/res/res/drawable-xxhdpi/ic_media_route_on_holo_light.png
Binary files differ
diff --git a/docs/html-intl/es/training/monitoring-device-state/battery-monitoring.jd b/docs/html-intl/intl/es/training/monitoring-device-state/battery-monitoring.jd
similarity index 100%
rename from docs/html-intl/es/training/monitoring-device-state/battery-monitoring.jd
rename to docs/html-intl/intl/es/training/monitoring-device-state/battery-monitoring.jd
diff --git a/docs/html-intl/es/training/monitoring-device-state/connectivity-monitoring.jd b/docs/html-intl/intl/es/training/monitoring-device-state/connectivity-monitoring.jd
similarity index 100%
rename from docs/html-intl/es/training/monitoring-device-state/connectivity-monitoring.jd
rename to docs/html-intl/intl/es/training/monitoring-device-state/connectivity-monitoring.jd
diff --git a/docs/html-intl/es/training/monitoring-device-state/docking-monitoring.jd b/docs/html-intl/intl/es/training/monitoring-device-state/docking-monitoring.jd
similarity index 100%
rename from docs/html-intl/es/training/monitoring-device-state/docking-monitoring.jd
rename to docs/html-intl/intl/es/training/monitoring-device-state/docking-monitoring.jd
diff --git a/docs/html-intl/es/training/monitoring-device-state/index.jd b/docs/html-intl/intl/es/training/monitoring-device-state/index.jd
similarity index 100%
rename from docs/html-intl/es/training/monitoring-device-state/index.jd
rename to docs/html-intl/intl/es/training/monitoring-device-state/index.jd
diff --git a/docs/html-intl/es/training/monitoring-device-state/manifest-receivers.jd b/docs/html-intl/intl/es/training/monitoring-device-state/manifest-receivers.jd
similarity index 100%
rename from docs/html-intl/es/training/monitoring-device-state/manifest-receivers.jd
rename to docs/html-intl/intl/es/training/monitoring-device-state/manifest-receivers.jd
diff --git a/docs/html-intl/es/training/multiscreen/adaptui.jd b/docs/html-intl/intl/es/training/multiscreen/adaptui.jd
similarity index 100%
rename from docs/html-intl/es/training/multiscreen/adaptui.jd
rename to docs/html-intl/intl/es/training/multiscreen/adaptui.jd
diff --git a/docs/html-intl/es/training/multiscreen/index.jd b/docs/html-intl/intl/es/training/multiscreen/index.jd
similarity index 100%
rename from docs/html-intl/es/training/multiscreen/index.jd
rename to docs/html-intl/intl/es/training/multiscreen/index.jd
diff --git a/docs/html-intl/es/training/multiscreen/screendensities.jd b/docs/html-intl/intl/es/training/multiscreen/screendensities.jd
similarity index 100%
rename from docs/html-intl/es/training/multiscreen/screendensities.jd
rename to docs/html-intl/intl/es/training/multiscreen/screendensities.jd
diff --git a/docs/html-intl/es/training/multiscreen/screensizes.jd b/docs/html-intl/intl/es/training/multiscreen/screensizes.jd
similarity index 100%
rename from docs/html-intl/es/training/multiscreen/screensizes.jd
rename to docs/html-intl/intl/es/training/multiscreen/screensizes.jd
diff --git a/docs/html-intl/ja/guide/publishing/app-signing.jd b/docs/html-intl/intl/ja/guide/publishing/app-signing.jd
similarity index 100%
rename from docs/html-intl/ja/guide/publishing/app-signing.jd
rename to docs/html-intl/intl/ja/guide/publishing/app-signing.jd
diff --git a/docs/html-intl/ja/guide/publishing/preparing.jd b/docs/html-intl/intl/ja/guide/publishing/preparing.jd
similarity index 100%
rename from docs/html-intl/ja/guide/publishing/preparing.jd
rename to docs/html-intl/intl/ja/guide/publishing/preparing.jd
diff --git a/docs/html-intl/ja/guide/publishing/versioning.jd b/docs/html-intl/intl/ja/guide/publishing/versioning.jd
similarity index 100%
rename from docs/html-intl/ja/guide/publishing/versioning.jd
rename to docs/html-intl/intl/ja/guide/publishing/versioning.jd
diff --git a/docs/html-intl/ja/guide/topics/fundamentals.jd b/docs/html-intl/intl/ja/guide/topics/fundamentals.jd
similarity index 100%
rename from docs/html-intl/ja/guide/topics/fundamentals.jd
rename to docs/html-intl/intl/ja/guide/topics/fundamentals.jd
diff --git a/docs/html-intl/ja/training/monitoring-device-state/battery-monitoring.jd b/docs/html-intl/intl/ja/training/monitoring-device-state/battery-monitoring.jd
similarity index 100%
rename from docs/html-intl/ja/training/monitoring-device-state/battery-monitoring.jd
rename to docs/html-intl/intl/ja/training/monitoring-device-state/battery-monitoring.jd
diff --git a/docs/html-intl/ja/training/monitoring-device-state/connectivity-monitoring.jd b/docs/html-intl/intl/ja/training/monitoring-device-state/connectivity-monitoring.jd
similarity index 100%
rename from docs/html-intl/ja/training/monitoring-device-state/connectivity-monitoring.jd
rename to docs/html-intl/intl/ja/training/monitoring-device-state/connectivity-monitoring.jd
diff --git a/docs/html-intl/ja/training/monitoring-device-state/docking-monitoring.jd b/docs/html-intl/intl/ja/training/monitoring-device-state/docking-monitoring.jd
similarity index 100%
rename from docs/html-intl/ja/training/monitoring-device-state/docking-monitoring.jd
rename to docs/html-intl/intl/ja/training/monitoring-device-state/docking-monitoring.jd
diff --git a/docs/html-intl/ja/training/monitoring-device-state/index.jd b/docs/html-intl/intl/ja/training/monitoring-device-state/index.jd
similarity index 100%
rename from docs/html-intl/ja/training/monitoring-device-state/index.jd
rename to docs/html-intl/intl/ja/training/monitoring-device-state/index.jd
diff --git a/docs/html-intl/ja/training/monitoring-device-state/manifest-receivers.jd b/docs/html-intl/intl/ja/training/monitoring-device-state/manifest-receivers.jd
similarity index 100%
rename from docs/html-intl/ja/training/monitoring-device-state/manifest-receivers.jd
rename to docs/html-intl/intl/ja/training/monitoring-device-state/manifest-receivers.jd
diff --git a/docs/html-intl/ja/training/multiscreen/adaptui.jd b/docs/html-intl/intl/ja/training/multiscreen/adaptui.jd
similarity index 100%
rename from docs/html-intl/ja/training/multiscreen/adaptui.jd
rename to docs/html-intl/intl/ja/training/multiscreen/adaptui.jd
diff --git a/docs/html-intl/ja/training/multiscreen/index.jd b/docs/html-intl/intl/ja/training/multiscreen/index.jd
similarity index 100%
rename from docs/html-intl/ja/training/multiscreen/index.jd
rename to docs/html-intl/intl/ja/training/multiscreen/index.jd
diff --git a/docs/html-intl/ja/training/multiscreen/screendensities.jd b/docs/html-intl/intl/ja/training/multiscreen/screendensities.jd
similarity index 100%
rename from docs/html-intl/ja/training/multiscreen/screendensities.jd
rename to docs/html-intl/intl/ja/training/multiscreen/screendensities.jd
diff --git a/docs/html-intl/ja/training/multiscreen/screensizes.jd b/docs/html-intl/intl/ja/training/multiscreen/screensizes.jd
similarity index 100%
rename from docs/html-intl/ja/training/multiscreen/screensizes.jd
rename to docs/html-intl/intl/ja/training/multiscreen/screensizes.jd
diff --git a/docs/html-intl/ko/training/monitoring-device-state/battery-monitoring.jd b/docs/html-intl/intl/ko/training/monitoring-device-state/battery-monitoring.jd
similarity index 100%
rename from docs/html-intl/ko/training/monitoring-device-state/battery-monitoring.jd
rename to docs/html-intl/intl/ko/training/monitoring-device-state/battery-monitoring.jd
diff --git a/docs/html-intl/ko/training/monitoring-device-state/connectivity-monitoring.jd b/docs/html-intl/intl/ko/training/monitoring-device-state/connectivity-monitoring.jd
similarity index 100%
rename from docs/html-intl/ko/training/monitoring-device-state/connectivity-monitoring.jd
rename to docs/html-intl/intl/ko/training/monitoring-device-state/connectivity-monitoring.jd
diff --git a/docs/html-intl/ko/training/monitoring-device-state/docking-monitoring.jd b/docs/html-intl/intl/ko/training/monitoring-device-state/docking-monitoring.jd
similarity index 100%
rename from docs/html-intl/ko/training/monitoring-device-state/docking-monitoring.jd
rename to docs/html-intl/intl/ko/training/monitoring-device-state/docking-monitoring.jd
diff --git a/docs/html-intl/ko/training/monitoring-device-state/index.jd b/docs/html-intl/intl/ko/training/monitoring-device-state/index.jd
similarity index 100%
rename from docs/html-intl/ko/training/monitoring-device-state/index.jd
rename to docs/html-intl/intl/ko/training/monitoring-device-state/index.jd
diff --git a/docs/html-intl/ko/training/monitoring-device-state/manifest-receivers.jd b/docs/html-intl/intl/ko/training/monitoring-device-state/manifest-receivers.jd
similarity index 100%
rename from docs/html-intl/ko/training/monitoring-device-state/manifest-receivers.jd
rename to docs/html-intl/intl/ko/training/monitoring-device-state/manifest-receivers.jd
diff --git a/docs/html-intl/ko/training/multiscreen/adaptui.jd b/docs/html-intl/intl/ko/training/multiscreen/adaptui.jd
similarity index 100%
rename from docs/html-intl/ko/training/multiscreen/adaptui.jd
rename to docs/html-intl/intl/ko/training/multiscreen/adaptui.jd
diff --git a/docs/html-intl/ko/training/multiscreen/index.jd b/docs/html-intl/intl/ko/training/multiscreen/index.jd
similarity index 100%
rename from docs/html-intl/ko/training/multiscreen/index.jd
rename to docs/html-intl/intl/ko/training/multiscreen/index.jd
diff --git a/docs/html-intl/ko/training/multiscreen/screendensities.jd b/docs/html-intl/intl/ko/training/multiscreen/screendensities.jd
similarity index 100%
rename from docs/html-intl/ko/training/multiscreen/screendensities.jd
rename to docs/html-intl/intl/ko/training/multiscreen/screendensities.jd
diff --git a/docs/html-intl/ko/training/multiscreen/screensizes.jd b/docs/html-intl/intl/ko/training/multiscreen/screensizes.jd
similarity index 100%
rename from docs/html-intl/ko/training/multiscreen/screensizes.jd
rename to docs/html-intl/intl/ko/training/multiscreen/screensizes.jd
diff --git a/docs/html-intl/ru/training/monitoring-device-state/battery-monitoring.jd b/docs/html-intl/intl/ru/training/monitoring-device-state/battery-monitoring.jd
similarity index 100%
rename from docs/html-intl/ru/training/monitoring-device-state/battery-monitoring.jd
rename to docs/html-intl/intl/ru/training/monitoring-device-state/battery-monitoring.jd
diff --git a/docs/html-intl/ru/training/monitoring-device-state/connectivity-monitoring.jd b/docs/html-intl/intl/ru/training/monitoring-device-state/connectivity-monitoring.jd
similarity index 100%
rename from docs/html-intl/ru/training/monitoring-device-state/connectivity-monitoring.jd
rename to docs/html-intl/intl/ru/training/monitoring-device-state/connectivity-monitoring.jd
diff --git a/docs/html-intl/ru/training/monitoring-device-state/docking-monitoring.jd b/docs/html-intl/intl/ru/training/monitoring-device-state/docking-monitoring.jd
similarity index 100%
rename from docs/html-intl/ru/training/monitoring-device-state/docking-monitoring.jd
rename to docs/html-intl/intl/ru/training/monitoring-device-state/docking-monitoring.jd
diff --git a/docs/html-intl/ru/training/monitoring-device-state/index.jd b/docs/html-intl/intl/ru/training/monitoring-device-state/index.jd
similarity index 100%
rename from docs/html-intl/ru/training/monitoring-device-state/index.jd
rename to docs/html-intl/intl/ru/training/monitoring-device-state/index.jd
diff --git a/docs/html-intl/ru/training/monitoring-device-state/manifest-receivers.jd b/docs/html-intl/intl/ru/training/monitoring-device-state/manifest-receivers.jd
similarity index 100%
rename from docs/html-intl/ru/training/monitoring-device-state/manifest-receivers.jd
rename to docs/html-intl/intl/ru/training/monitoring-device-state/manifest-receivers.jd
diff --git a/docs/html-intl/ru/training/multiscreen/adaptui.jd b/docs/html-intl/intl/ru/training/multiscreen/adaptui.jd
similarity index 100%
rename from docs/html-intl/ru/training/multiscreen/adaptui.jd
rename to docs/html-intl/intl/ru/training/multiscreen/adaptui.jd
diff --git a/docs/html-intl/ru/training/multiscreen/index.jd b/docs/html-intl/intl/ru/training/multiscreen/index.jd
similarity index 100%
rename from docs/html-intl/ru/training/multiscreen/index.jd
rename to docs/html-intl/intl/ru/training/multiscreen/index.jd
diff --git a/docs/html-intl/ru/training/multiscreen/screendensities.jd b/docs/html-intl/intl/ru/training/multiscreen/screendensities.jd
similarity index 100%
rename from docs/html-intl/ru/training/multiscreen/screendensities.jd
rename to docs/html-intl/intl/ru/training/multiscreen/screendensities.jd
diff --git a/docs/html-intl/ru/training/multiscreen/screensizes.jd b/docs/html-intl/intl/ru/training/multiscreen/screensizes.jd
similarity index 100%
rename from docs/html-intl/ru/training/multiscreen/screensizes.jd
rename to docs/html-intl/intl/ru/training/multiscreen/screensizes.jd
diff --git a/docs/html-intl/zh-cn/training/monitoring-device-state/battery-monitoring.jd b/docs/html-intl/intl/zh-cn/training/monitoring-device-state/battery-monitoring.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/monitoring-device-state/battery-monitoring.jd
rename to docs/html-intl/intl/zh-cn/training/monitoring-device-state/battery-monitoring.jd
diff --git a/docs/html-intl/zh-cn/training/monitoring-device-state/connectivity-monitoring.jd b/docs/html-intl/intl/zh-cn/training/monitoring-device-state/connectivity-monitoring.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/monitoring-device-state/connectivity-monitoring.jd
rename to docs/html-intl/intl/zh-cn/training/monitoring-device-state/connectivity-monitoring.jd
diff --git a/docs/html-intl/zh-cn/training/monitoring-device-state/docking-monitoring.jd b/docs/html-intl/intl/zh-cn/training/monitoring-device-state/docking-monitoring.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/monitoring-device-state/docking-monitoring.jd
rename to docs/html-intl/intl/zh-cn/training/monitoring-device-state/docking-monitoring.jd
diff --git a/docs/html-intl/zh-cn/training/monitoring-device-state/index.jd b/docs/html-intl/intl/zh-cn/training/monitoring-device-state/index.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/monitoring-device-state/index.jd
rename to docs/html-intl/intl/zh-cn/training/monitoring-device-state/index.jd
diff --git a/docs/html-intl/zh-cn/training/monitoring-device-state/manifest-receivers.jd b/docs/html-intl/intl/zh-cn/training/monitoring-device-state/manifest-receivers.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/monitoring-device-state/manifest-receivers.jd
rename to docs/html-intl/intl/zh-cn/training/monitoring-device-state/manifest-receivers.jd
diff --git a/docs/html-intl/zh-cn/training/multiscreen/adaptui.jd b/docs/html-intl/intl/zh-cn/training/multiscreen/adaptui.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/multiscreen/adaptui.jd
rename to docs/html-intl/intl/zh-cn/training/multiscreen/adaptui.jd
diff --git a/docs/html-intl/zh-cn/training/multiscreen/index.jd b/docs/html-intl/intl/zh-cn/training/multiscreen/index.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/multiscreen/index.jd
rename to docs/html-intl/intl/zh-cn/training/multiscreen/index.jd
diff --git a/docs/html-intl/zh-cn/training/multiscreen/screendensities.jd b/docs/html-intl/intl/zh-cn/training/multiscreen/screendensities.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/multiscreen/screendensities.jd
rename to docs/html-intl/intl/zh-cn/training/multiscreen/screendensities.jd
diff --git a/docs/html-intl/zh-cn/training/multiscreen/screensizes.jd b/docs/html-intl/intl/zh-cn/training/multiscreen/screensizes.jd
similarity index 100%
rename from docs/html-intl/zh-cn/training/multiscreen/screensizes.jd
rename to docs/html-intl/intl/zh-cn/training/multiscreen/screensizes.jd
diff --git a/docs/html/about/dashboards/index.jd b/docs/html/about/dashboards/index.jd
index bb34495..4735033 100644
--- a/docs/html/about/dashboards/index.jd
+++ b/docs/html/about/dashboards/index.jd
@@ -61,7 +61,7 @@
 </div>
 
 
-<p style="clear:both"><em>Data collected during a 7-day period ending on November 1, 2013.
+<p style="clear:both"><em>Data collected during a 7-day period ending on December 2, 2013.
 <br/>Any versions with less than 0.1% distribution are not shown.</em>
 </p>
 
@@ -92,7 +92,7 @@
 </div>
 
 
-<p style="clear:both"><em>Data collected during a 7-day period ending on November 1, 2013
+<p style="clear:both"><em>Data collected during a 7-day period ending on December 2, 2013
 <br/>Any screen configurations with less than 0.1% distribution are not shown.</em></p>
 
 
@@ -133,17 +133,17 @@
 </tr>
 <tr>
 <td>2.0</th>
-<td>98.3%</td>
+<td>96.3%</td>
 </tr>
 <tr>
 <td>3.0</th>
-<td>1.6%</td>
+<td>3.6%</td>
 </tr>
 </table>
 
 
 
-<p style="clear:both"><em>Data collected during a 7-day period ending on November 1, 2013</em></p>
+<p style="clear:both"><em>Data collected during a 7-day period ending on December 2, 2013</em></p>
 
 
 
@@ -161,17 +161,17 @@
 var VERSION_DATA =
 [
   {
-    "chart": "//chart.googleapis.com/chart?chl=Froyo%7CGingerbread%7CHoneycomb%7CIce%20Cream%20Sandwich%7CJelly%20Bean&chco=c4df9b%2C6fad0c&chd=t%3A1.7%2C26.3%2C0.1%2C19.8%2C52.1&chf=bg%2Cs%2C00000000&chs=500x250&cht=p",
+    "chart": "//chart.googleapis.com/chart?cht=p&chs=500x250&chf=bg%2Cs%2C00000000&chd=t%3A1.6%2C24.1%2C0.1%2C18.6%2C54.5%2C1.1&chl=Froyo%7CGingerbread%7CHoneycomb%7CIce%20Cream%20Sandwich%7CJelly%20Bean%7CKitKat&chco=c4df9b%2C6fad0c",
     "data": [
       {
         "api": 8,
         "name": "Froyo",
-        "perc": "1.7"
+        "perc": "1.6"
       },
       {
         "api": 10,
         "name": "Gingerbread",
-        "perc": "26.3"
+        "perc": "24.1"
       },
       {
         "api": 13,
@@ -181,22 +181,27 @@
       {
         "api": 15,
         "name": "Ice Cream Sandwich",
-        "perc": "19.8"
+        "perc": "18.6"
       },
       {
         "api": 16,
         "name": "Jelly Bean",
-        "perc": "37.3"
+        "perc": "37.4"
       },
       {
         "api": 17,
         "name": "Jelly Bean",
-        "perc": "12.5"
+        "perc": "12.9"
       },
       {
         "api": 18,
         "name": "Jelly Bean",
-        "perc": "2.3"
+        "perc": "4.2"
+      },
+      {
+        "api": 19,
+        "name": "KitKat",
+        "perc": "1.1"
       }
     ]
   }
@@ -213,28 +218,28 @@
       "Large": {
         "hdpi": "0.5",
         "ldpi": "0.6",
-        "mdpi": "3.6",
-        "tvdpi": "1.2",
-        "xhdpi": "0.5"
+        "mdpi": "3.8",
+        "tvdpi": "1.4",
+        "xhdpi": "0.6"
       },
       "Normal": {
         "hdpi": "33.4",
         "ldpi": "0.1",
-        "mdpi": "15.1",
-        "xhdpi": "22.2",
-        "xxhdpi": "8.8"
+        "mdpi": "14.6",
+        "xhdpi": "21.6",
+        "xxhdpi": "9.7"
       },
       "Small": {
-        "ldpi": "9.2"
+        "ldpi": "8.8"
       },
       "Xlarge": {
         "hdpi": "0.3",
-        "mdpi": "4.4",
+        "mdpi": "4.5",
         "xhdpi": "0.1"
       }
     },
-    "densitychart": "//chart.googleapis.com/chart?chl=ldpi%7Cmdpi%7Ctvdpi%7Chdpi%7Cxhdpi%7Cxxhdpi&chco=c4df9b%2C6fad0c&chd=t%3A9.9%2C23.1%2C1.2%2C34.2%2C22.8%2C8.8&chf=bg%2Cs%2C00000000&chs=400x250&cht=p",
-    "layoutchart": "//chart.googleapis.com/chart?chl=Xlarge%7CLarge%7CNormal%7CSmall&chco=c4df9b%2C6fad0c&chd=t%3A4.8%2C6.4%2C79.6%2C9.2&chf=bg%2Cs%2C00000000&chs=400x250&cht=p"
+    "densitychart": "//chart.googleapis.com/chart?cht=p&chs=400x250&chf=bg%2Cs%2C00000000&chd=t%3A9.5%2C22.9%2C1.4%2C34.2%2C22.3%2C9.7&chl=ldpi%7Cmdpi%7Ctvdpi%7Chdpi%7Cxhdpi%7Cxxhdpi&chco=c4df9b%2C6fad0c",
+    "layoutchart": "//chart.googleapis.com/chart?cht=p&chs=400x250&chf=bg%2Cs%2C00000000&chd=t%3A4.9%2C6.9%2C79.4%2C8.8&chl=Xlarge%7CLarge%7CNormal%7CSmall&chco=c4df9b%2C6fad0c"
   }
 ];
 
@@ -301,6 +306,11 @@
     "api":18,
     "link":"<a href='/about/versions/android-4.3.html'>4.3</a>",
     "codename":"Jelly Bean"
+  },
+  {
+    "api":19,
+    "link":"<a href='/about/versions/android-4.4.html'>4.4</a>",
+    "codename":"KitKat"
   }
 ];
 
diff --git a/docs/html/about/versions/android-4.4.jd b/docs/html/about/versions/android-4.4.jd
index 42f257c..3de2acc 100644
--- a/docs/html/about/versions/android-4.4.jd
+++ b/docs/html/about/versions/android-4.4.jd
@@ -244,7 +244,7 @@
 
 <p>If you want to emulate an NFC card that is using these protocols in your app, create a service component based on the {@link android.nfc.cardemulation.HostApduService} class. Whereas if your app instead uses a secure element for card emulation, you need to create a service based on the {@link android.nfc.cardemulation.OffHostApduService} class, which will not directly be involved in the transactions but is necessary to register the AIDs that should be handled by the secure element.</p>
 
-<p>For more information, read the <a href="">NFC Card Emulation</a> guide.</p>
+<p>For more information, read the <a href="{@docRoot}guide/topics/connectivity/nfc/hce.html">NFC Card Emulation</a> guide.</p>
 
 
 <h3 id="ReaderMode">NFC reader mode</h3>
diff --git a/docs/html/about/versions/jelly-bean.jd b/docs/html/about/versions/jelly-bean.jd
index c6702b0..25f88e3 100644
--- a/docs/html/about/versions/jelly-bean.jd
+++ b/docs/html/about/versions/jelly-bean.jd
@@ -578,9 +578,10 @@
 graph for each visible Activity, including the navigation bar and notification
 bar. </p>
 
-<p>A green line highlights the <strong>60ms threshold</strong> for rendering
+<p>A green line highlights the <strong>16ms threshold</strong> for rendering
 operations, so you can assess the your app’s effective framerate relative
-to a 60 fps goal. If you see operations that cross the green line, you
+to a 60 fps goal (because 1/60th of a second equals roughly 16ms).
+If you see operations that cross the green line, you
 can analyze them further using Systrace and other tools.</p>
 
 <p class="caution" style="clear:both">On devices running Android 4.2 and higher,
diff --git a/docs/html/about/versions/kitkat.jd b/docs/html/about/versions/kitkat.jd
index 5e442ec..4237c98 100644
--- a/docs/html/about/versions/kitkat.jd
+++ b/docs/html/about/versions/kitkat.jd
@@ -54,8 +54,8 @@
 <!-- BEGIN ANDROID 4.4 -->
 <div id="44-android-44" class="version-section">
 
-  <div style="padding:0px 0px 0px 60px;margin-top:-3px;float:right;">
-    <img src="{@docRoot}design/media/index_landing_page.png" alt="Android 4.4 on phone and tablet" width="380">
+  <div style="padding:0px 0px 0px 60px;margin-top:-20px;float:right;">
+    <img src="{@docRoot}images/kk-devices.png" alt="Android 4.4 on phone and tablet" width="380">
   </div>
 
   <div class="landing-docs" style="float:right;clear:both;margin:22px 0 2em 3em;">
diff --git a/docs/html/channels/io2013.jd b/docs/html/channels/io2013.jd
index 977eb2f..2efda28 100644
--- a/docs/html/channels/io2013.jd
+++ b/docs/html/channels/io2013.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 fullpage=true
 page.title=Google I/O 13
 @jd:body
diff --git a/docs/html/community/index.html b/docs/html/community/index.html
new file mode 100644
index 0000000..eeb1c51
--- /dev/null
+++ b/docs/html/community/index.html
@@ -0,0 +1,317 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="viewport" content="width=device-width" />
+
+<meta name="google-site-verification" content="sa-bIAI6GKvct3f61-WpRguHq-aNjtF7xJjMTSi79as" />
+<link rel="shortcut icon" type="image/x-icon" href="/favicon.ico" />
+<title>Android Developers Community</title>
+
+<!-- STYLESHEETS -->
+<link rel="stylesheet"
+href="//fonts.googleapis.com/css?family=Roboto:regular,medium,thin,italic,mediumitalic,bold" title="roboto">
+<link href="/assets/css/default.css" rel="stylesheet" type="text/css">
+
+<!-- JAVASCRIPT -->
+<script src="//www.google.com/jsapi" type="text/javascript"></script>
+<script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
+<script type="text/javascript">
+  var toRoot = "/";
+  var devsite = false;
+</script>
+
+<script type="text/javascript">
+  var _gaq = _gaq || [];
+  _gaq.push(['_setAccount', 'UA-5831155-1']);
+  _gaq.push(['_trackPageview']);
+
+  (function() {
+    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+  })();
+</script>
+
+<style>
+#header-wrap h1 {
+  margin:0;
+  padding:0;
+  line-height:16px;
+}
+#body-content {
+  margin-top:20px;
+}
+#nav-x.wrap {
+  overflow:auto;
+}
+h2 {
+  border-bottom:1px solid #CCC;
+}
+</style>
+</head>
+
+
+
+
+
+
+<body>
+
+
+<!-- Header -->
+<div id="header">
+  <div class="wrap" id="header-wrap">
+    <div class="col-3 logo">
+      <a href="/index.html">
+        <img src="http://developer.android.com/assets/images/dac_logo.png" width="123" height="25" alt="Android Developers" />
+      </a>
+    </div>
+    <div class="col-8">
+      <h1>Community Outreach</h1>
+    </div>
+
+    <div class="menu-container">
+    <div class="moremenu">
+      <div id="more-btn"></div>
+    </div>
+    <div class="morehover" id="moremenu">
+      <div class="top"></div>
+      <div class="mid">
+        <div class="header">Links</div>
+        <ul style="margin-bottom:0">
+          <li><a href="https://www.youtube.com/user/androiddevelopers">Android Developers Live</a></li>
+          <li><a href="http://android-developers.blogspot.com/">Android Developers Blog</a></li>
+          <li><a href="http://developer.android.com/training/">Android Developer Training</a></li>
+          <li><a href="http://developer.android.com/samples/">Samples</a></li>
+        </ul>
+        <br class="clear-fix">
+    </div>
+      <div class="bottom"></div>
+    </div><!-- end morehover -->
+  </div><!-- end menu-container -->
+  </div><!-- end header-wrap -->
+</div>
+<!-- /Header -->
+
+<div id="nav-x" class="wrap">
+    <ul class="nav-x col-9 develop">
+  <li><a href="#News">News</a></li>
+  <li><a href="#Community">Community</a></li>
+  <li><a href="#Content">Content</a></li>
+  <li><a href="#Social">Social</a></li>
+  </ul>
+</div>
+
+
+<!-- MAIN CONTENT -->
+
+
+<div class="wrap" id="body-content">
+
+<img src="/images/community/aco1small.png" alt="" style="float:right;margin:20px 0 0 40px">
+
+<p style="clear:left">
+  Android is working with communities to 
+<ul>
+<li>Create a cooperative relationship between highly impactful communities and high performing developers</li>
+<li>Strengthen relationships between Android and coding communities so that developers have a motivation to interact with those communities</li>
+<li>Reward communities for attracting developers by providing them with resources and direct access to the Android team</li></ul>
+<p>Our IMPACT is measured by <strong>good apps</strong> and a <strong>thriving community</strong></p>
+
+<h2 id="News" style="clear:left">News</h2>
+<p>Our current theme is on the <b><em>Android 4.4 KitKat and Updated Developer Tools</em></b> release, with new ways to create beautiful apps, printing and storage frameworks, low-power sensors, new media capabilities and RenderScript in the NDK.</p>
+
+<div class="col-8" style="margin-left:0">
+<img src="/images/community/kk-hero2.jpg" alt="" height="277">
+</div>
+
+<div class="col-8" style="margin-right:0">
+<h3 style="margin-top:0"><a href="http://developer.android.com/about/versions/kitkat.html">Android 4.4 Platform Highlights</a></h3>
+<p>Android KitKat brings all of Android's most innovative, most beautiful, and most useful features to more devices everywhere.</p>
+
+<h3><a href="http://developer.android.com/about/versions/android-4.4.html">Android 4.4 APIs</a></h3>
+<p>Android 4.4 (KITKAT) is a new release for the Android platform that offers new features for users and app developers. This document provides an introduction to the most notable new APIs.</p>
+
+<h3><a href="https://play.google.com/store/devices/details?id=nexus_5_white_32gb">New Nexus 5</a></h3>
+<p>Nexus 5 helps you capture the everyday and the epic in fresh new ways. It's the slimmest and fastest Nexus phone ever made, powered by Android 4.4, KitKat.</p>
+</div>
+<p></p>
+
+<h2 id="Community" style="clear:left">Community Spotlight</h2>
+
+<div class="col-8" style="margin-left:0">
+<h3>Android Community Groups</h3>
+<h4>July 2013</h4>
+<p><a href="mailto:gtugam@gmail.com">GDG Armenia</a> held <a href="http://eca.hackathon.am/">ecaHack Yerevan</a>, an Android hackathon featuring &quot;Angry Designers vs Android Developers&quot;, where the designers had a look into developers apps and gave them some advices regarding to design. The hackathon was sponsored by Alcatel One Touch and each member of the winner team got one Alcatel One Touch Idol. Check out the <a href="https://plus.google.com/u/0/events/gallery/cgj9d39gphiephlq0e2899dv6j4?cfem=1">photos.</a></p>
+<h4>September 2013</h4>
+<p><a href="mailto:soham.mondal@gmail.com">GDG Blrdroid</a> held a <a href="http://www.meetup.com/blrdroid/events/140665852/">meetup</a> on performance optimisation.</p>
+<p><a href="mailto:baileye@gmail.com">GDG Dublin</a> held their meetup with a talk on AdMob for Android and iOS, entitled &ldquo;Admob for Android and iOS developers&rdquo;. </p>
+<p>GDG Mbale&rsquo;s <a href="mailto:nsubugahassan@gmail.com">Hassan Nsubuga</a> has been managing a university <a href="https://plus.google.com/103735976334615631393/posts/gQMWCGUhMBn">course session</a> since September. They are now through with the basics and have a firm foundation, so this month they will be doing a lot of advanced stuff including exploring the latest API enhancements with KitKat. </p>
+<p><a href="mailto:wojtek.kalicinski@gmail.com">GDG Warsaw</a> held an Android Barcamp focused on App Quality. The discussion was moderated by GDG organisers, but the talks were given by the community members, including some top Android companies and developers in Poland.</p>
+<h4>October 2013</h4>
+<p><a href="mailto:benjamin.r.m.weiss@gmail.com">GDG Berlin Android</a> held their <a href="https://berlin.ticketbud.com/devfest-berlin-2013">DevFest</a>.</p>
+<p><a href="mailto:soham.mondal@gmail.com">GDG Blrdroid</a> held their <a href="http://www.meetup.com/blrdroid/events/144457162/">meetup</a> in collaboration with GDG Bangalore, where they talked about a wider range of things from incorporating user feedback to effectively using the cell radio. David McLaughlin from the Developer Relations team also visited during the meetup and delivered the keynote. They also hit a milestone with its 4th anniversary on the 9th of October and crossed 4300 members in the past few days so its been a memorable couple of months for them.</p>
+<p><a href="mailto:hir3npatel@gmail.com">GDG Cape Town</a> held an <a href="https://plus.google.com/108309780217630451504/posts/9BTCEqnBHoQ">Android Workshop</a> where they gave away lots of branded KitKats.</p>
+<p><a href="mailto:baileye@gmail.com">GDG Dublin</a> held its DevFest, which featured a codeLab on Android titled &ldquo;Codelab: Intro to Android Development.&rdquo;</p>
+<p><a href="mailto:hugo@dutchaug.org">GDG Dutch Android User Group</a> held their <a href="http://www.devfest.nl/program">DevFest</a>. They had a bunch of Android sessions, mostly by local speakers. In addition to the Android sessions, they also ran a workshop on writing custom views.</p>
+<p><a href="mailto:hugo@dutchaug.org">Hugo Visser</a> from the Dutch Android User Group spoke at <a href="https://bitbucket.org/qbusict/cupboard">DroidCon UK barcamp</a>, where he delivered a talk on Cupboard, a simple and lightweight persistence framework, specifically for Android.</p> 
+<p><a href="mailto:prajyotmainkar@gmail.com">GDG GAUG</a> held the <a href="https://plus.google.com/110448195989468248957/posts/8doJuCpySWS">Google Devfest 2013</a>, where they had two tracks and more than 200 delegates attending. They also had a <a href="https://plus.google.com/110448195989468248957/posts/6rxLzj2Rpde">Hackathon</a> and they hit the <a href="https://plus.google.com/110448195989468248957">1000 member</a> mark this month, which makes them the second largest android community in India after GDG Blrdroid. </p>
+<p><a href="mailto:cyrilleguipie@gmail.com">GDG Miage</a> held their DevFest where they gave a talk about Intents and Services. The also held a startup Weekend Bootcamp where they talked about Activites and Layouts. They will also hold an Android Workshop in December.</p>
+<p><a href="mailto:gabriel.kb@gmail.com">GDG Uruguay</a> had their <a href="http://gdg.uy/devfest2013">DevFest</a>, where they held an Android workshop for beginners as an Android vs iOS comparison, a session on best practices using YouTube APIs in Android, and &nbsp;What's new in Google for developers (with a special section about Android). You can see pictures on <a href="https://plus.google.com/114520966453242230657/posts/dqZAuMqc12Z">the G+ page</a>. </p>
+
+<h4>November 2013</h4>
+<p><a href="mailto:yorogoule@gmail.com">Abidjandroid/GDG Côte d'Ivoire</a> held an Android Launch Party featuring the KitKat release.</p>
+<p>The <a href="mailto:hugo@dutchaug.org">Dutch Android User Group</a> had a very interactive presentation on Android Code Puzzlers and Tips &amp; tricks, where they rewarded participation by giving out books, tshirts, jelly beans and kitkats. The presentation was at the <a href="http://www.nljug.org/jfall">Dutch JFall conference</a>, organized by the NLJUG. It's a large yearly Java conference and the DAUG had the only Android session there.</p>
+<p>The <a href="mailto:benjamin.r.m.weiss@gmail.com">GDG Berlin Android</a> meetup this month  featured the KitKat release.</p>
+<p><a href="mailto:soham.mondal@gmail.com">The GDG Blrdroid</a> <a href="http://www.meetup.com/blrdroid/events/148210762/%20">meetup</a> was another focused on KitKat.</p>
+<p>At the <a href="mailto:amahdy7@gmail.com">GDG Cairo</a> <a href="https://plus.google.com/events/co59j0870in5a4kh8n5navifnm8">DevFest</a> there was a &quot;What's new in Android SDK&quot; session on day 1, and an Android workshop on day 2. Kitkat also provided interest in the sessions and the snacks bar. The KitKat <a href="http://buff.ly/HNE7yq">presentation</a>, the track organization, and everything related to it were all organized by women.</p>
+<p><a href="mailto:hir3npatel@gmail.com">GDG Cape Town</a> held an Android Workshop.</p>
+<p><a href="mailto:alessandro.gbridge@gmail.com">GDG Udine</a>  organized a talk after the release of KitKat for a school in Pordenone.</p>
+<p><a href="mailto:hugo@dutchaug.org">Hugo Visser</a> from Droidcon Netherlands  organized an Android hackathon themed &quot;Location, Location, Location&quot;. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; </p>
+<p><a href="mailto:eyal.lezmy@gmail.com">Paris Android User Group</a> welcomed <a href="https://plus.google.com/+RomainGuy">Romain Guy</a> and <a href="https://plus.google.com/+ChetHaase">Chet Haase</a> to their meetup this month. They&rsquo;ll be meeting up with other GDG leads and UG managers meet at <a href="https://plus.google.com/events/cupo201fjreo9g9t2e596gv8nd4">Devoxx</a> next Thursday.</p>
+<p><a href="mailto:wojtek.kalicinski@gmail.com">GDG Warsaw</a> had over 250 attendees at their DevFest, which featured session tracks on Android and Web and a whole day of Code Labs in Android, AngularJS and Arduino.</p>
+<h4>December 2013</h4>
+<p><a href="mailto:prajyotmainkar@gmail.com">GDG GAUG</a> are planning a codelab and hackathon.</p>
+<p><a href="mailto:psvensson@gmail.com">Peter Svensson</a> spoke at <a href="http://swdc.se/droidcon/events/stockholm-2013/">DroidCon Stockholm</a></p>
+The unstoppable <a href="mailto:bonbhel@gmail.com">Max Bonbhel</a> from the African GDG Android is hosting AAC 2014 and Android GDG Barcamp events in December. Also, in order to encourage African Java developers to move to the Android platform, he created the <a href="https://docs.google.com/spreadsheet/ccc?key=0AtFPan-z2ps-dHBtX1luY2pRQjdtRjliUGcxMVBNeVE&usp=sharing#gid=0">Africa Android Training (AAT) program</a>. The training material targets developers with different levels of experience in Java development. More than 60 developers have been taking part in the weekly sessions. The next 10 sessions will start Saturday, November 9, 2013. 260 GDG and Java User Group members have already registered from 12 Countries.
+<p>&nbsp;</p>
+</div>
+
+<div class="col-8" style="margin-right:0">
+<h3>Android Community Experts</h3>
+
+<h4>October 2013</h4>
+<p><a href="mailto:eyal.lezmy@gmail.com">Eyal Lezmy</a> presented two sessions. &ldquo;<a href="http://bit.ly/andbigfail">Play Store bashing, learn from the biggest fails</a>&rdquo; looked at several applications, mainly developed by huge companies, and analyzed why they failed to satisfy the users or the Android guidelines. &ldquo;<a href="http://bit.ly/lifeofapp">Android, the life of your app</a>&rdquo; tells a story, living the life of a user, identify the frustrations he can encounter and present ways to avoid it, as a developer.</p>
+<p><a href="mailto:mariux01@gmail.com">Mario Viviani</a> presented and recorded the next <a href="http://www.youtube.com/watch?v=jaT0bYhhaGY">Android App Clinic - Italia</a>. This episode was regarding the Cards UI and SMS app support in Android 4.4. They experimented with a short form of the video (10 minutes instead of 20) and in less than day it got almost 400+ views -- which is great considering it's in Italian! The previous episode reached 1300 views all-time and was the most successful video of GDL Italia in Q2.</p>
+<p><a href="mailto:m.kaeppler@gmail.com">Matthias Käppler</a> contributed the <a href="https://github.com/Netflix/RxJava/tree/master/rxjava-contrib/rxjava-android">first Android specific component</a> to the RxJava project, and spoke about <a href="http://uk.droidcon.com/2013/sessions/conquering-concurrency-bringing-the-reactive-extensions-to-the-android-platform/">RxJava and reactive programming on Android</a> at DroidCon UK. He has also open sourced <a href="https://github.com/mttkay/memento">Memento</a>, an Android annotation processor to replace the deprecated onRetainNonConfigurationInstance.</p>
+<p><a href="mailto:wojtek.kalicinski@gmail.com">Wojtek Kaliciński</a>&rsquo;s talk, &quot;Android - is it time for a break yet?&quot; highlights not only what's new in Android 4.4 KitKat, but also how to take your app to the next level by making sure you provide the best app experience possible to all 4.0+ users.</p>
+<a href="https://plus.sandbox.google.com/110448195989468248957/posts"><img src="/images/community/hackathon-gdgaug.jpg" alt=""  align="right"></a>
+
+</div>
+
+<h2 id="Content" style="clear:left">New Content</h2>
+<div class="col-8" style="margin-left:0">
+<p><h4>Android 4.4 What's New</h4>
+KitKat has been optimized to run on a much broader range of devices, with special focus on the millions of entry-level devices that have as little as 512MB RAM. To help, we've created new APIs, better tools, and better documentation to let you create apps that perform well on all devices.<br>
+Check out this video summary of some of the most significant developer features in the latest Android release, including  new ways to make your apps beautiful, NFC Host Card Emulation, a printing framework, the storage access framework, low-power step detector and step counter sensors, and more!<br>
+<h5><a href="http://www.youtube.com/watch?v=sONcojECWXs&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<i>Be sure to get the <a href="http://developer.android.com/about/versions/android-4.4.html">full Android 4.4 API Overview</a>, and take a look at our <a href="https://www.youtube.com/playlist?list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">related DevBytes videos</a></i></p>
+
+<p><h4>WebView in Android 4.4</h4>
+Android 4.4 (API level 19) introduces a new version of WebView that is based on Chromium. This change upgrades WebView performance and standards support for HTML5, CSS3, and JavaScript to match the latest web browsers. Any apps using WebView will inherit these upgrades when running on Android 4.4 and higher.
+<h5><a href="http://developer.android.com/guide/webapps/migrating.html">API Guide</a></h5>
+</p>
+
+<p><h4>Android 4.4 Immersive Mode</h4>
+With Android 4.4 KitKat, your apps can now truly go full-screen with a new Immersive Mode. Immersive Mode lets your apps hide the system's status and navigation bars while capturing all touch events—ideal for rich interactive content such as books and games. This video demonstrates how to use the new API, in addition to recapping earlier full-screen APIs on Android.
+<h5><a href="http://www.youtube.com/watch?v=cBi8fjv90E4&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<h5><a href="http://developer.android.com/samples/ImmersiveMode/index.html">Sample</a></h5>
+</p>
+
+<p>
+<h4>Android 4.4 Storage Access Framework - Provider</h4>
+Get up to speed on the new document storage API in Android 4.4 KitKat. This video gets you up and running with your own DocumentProvider by stepping you through the making of a simple cloud storage app.
+<h5><a href="http://www.youtube.com/watch?v=zxHVeXbK1P4&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<h5><a href="http://developer.android.com/guide/topics/providers/document-provider.html">Training</a></h5>
+<h5><a href="http://developer.android.com/samples/StorageProvider/index.html">Sample</a>, <a href="https://play.google.com/store/apps/details?id=com.box.android">Box Application</a></h5>
+</blockquote>
+
+</p>
+
+
+<p><h4>Android 4.4 Storage Access Framework - Client</h4>
+Get up to speed on the new storage access framework in Android 4.4 KitKat. This video teaches you how to quickly create, edit, save and delete documents provided by other apps as a client of the storage access framework.
+<h5><a href="http://www.youtube.com/watch?v=UFj9AEz0DHQ&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<h5><a href="http://developer.android.com/samples/StorageClient/index.html">Sample</a></h5>
+</p>
+
+<p><h4>Android 4.4 Closed Captioning</h4>
+Displaying closed captions in your app's videos can be quick and simple in Android 4.4 KitKat,. Learn how to attach timed text tracks to VideoView and allow users to customize how captions are displayed.
+<h5><a href="http://www.youtube.com/watch?v=hCRGc2PcmB8&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a>
+</p>
+</h5>
+</div>
+
+<div class="col-8" style="margin-right:0">
+
+<p>
+<h4>Android 4.4 Transitions</h4>
+In this episode, we introduce the new Transitions API in Android 4.4 Kitkat. This API provides a simple way for developers to provide animated segues to different scenes of their application, helping users to understand the application flow with very little code. The general approach is to tell the system that you'd like to run a transition animation, then make the necessary changes to your UI. The system figures out the differences and animates the changes.
+<h5><a href="http://www.youtube.com/watch?v=S3H7nJ4QaD8&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K&index=3">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></p>
+</h5>
+<p><h4>Android 4.4: SMS APIs</h4>
+Android 4.4 KitKat introduces the new SMS APIs as well as the new concept of a default SMS app. This video discusses these new APIs and how your app should use them to send and receive SMS and MMS messages.<br>
+<h5><a href="http://www.youtube.com/watch?v=mdq0R2WQssQ&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<i>See also -<br>
+<a href="http://goo.gl/sw5NdH">Android Developer Blog post on Android 4.4 KitKat SMS APIs</a><br>
+<a href="http://goo.gl/7vTx3s">Android Protip on using booleans in your AndroidManifest.xml</a></i></p>
+
+
+<p><h4>Android 4.4 Printing API</h4>
+In this video, we introduce the new Printing API in Android 4.4 KitKat. This API provides a simple way for developers to print to cloud-connected printers using Google Cloud Print. It's really easy to print bitmaps, and HTML (that you generate on the device, or just web content).<br>
+<h5><a href="http://www.youtube.com/watch?v=Iub67ic87KI&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a></h5>
+<h5><a href="http://developer.android.com/training/printing/index.html">Training</a></h5>
+<i>Some pro-tips:</i>
+<ul>
+  <li>For Webview/HTML printing, printing from javascript is not supported yet (window.print() for example). Also we are planning to address the limitations around WebView/HTML printing in future releases (eg: headers/footers, and specifying print ranges).</li>
+<li>We encourage developers to open Android Open Source bugs for features that they feel important as a feedback.</li>
+</ul>
+
+<p><h4>App Indexing</h4>
+In this episode we discuss the new App Indexing feature that we recently announced for Google Search for Android.<br>
+Currently, when you do a google search on the web, you get results that are links to websites. With App Indexing, you will be able to point Google Search users on Android directly to content within your app!
+If you’re an Android app developer who has a web presence and you want more control over how your content is accessed from search, via your website or Android app, App Indexing is a great feature for you to explore.
+Also, enabling your website and app for indexing is a way to increase engagement with your app by making the content more discoverable, and more accessible to users directly from the search results page.
+For information on App Indexing, please visit <a href="http://g.co/appindexing">http://g.co/appindexing</a>
+<h5><a href="http://www.youtube.com/watch?v=Xh_W82JgOms&list=PLWz5rJ2EKKc-2quE-o0enpILZF3nBZg_K">Video</a></h5>
+<h5><a href="https://drive.google.com/a/google.com/folderview?id=0BwhAiXVwzMoFc28wWEpyeE9qYTQ&usp=sharing">Presentation</a>
+</p>
+</h5>
+</div>
+
+<h2 id="Social" style="clear:left">Social</h2>
+<div class="col-8" style="margin-left:0">
+
+<h3 >G+</h3>
+
+<ul>
+<li><a href="https://plus.google.com/u/1/108967384991768947849/posts/1iVvwyfTM8y">What's New in Android 4.4</a>
+  <ul>
+    <li><a href="http://www.youtube.com/watch?v=HrFRY32i_sE">What's New in Android 4.4 [JAPANESE!]</a></li>
+    <li><a href="https://www.youtube.com/watch?v=U9jAcwaETD4">What's New in Android 4.4 [KOREAN!]</a></li>
+    <li><a href="https://plus.google.com/u/1/108967384991768947849/posts/WfqdvDG2Cyr">Quer saber das novidades do Android 4.4? [PORTUGUESE!]</a></li>
+  </ul>
+</li>
+<li><a href="https://plus.google.com/u/1/+AndroidDevelopers/posts/femjRbay18f">Android 4.4 and Updated Developer Tools 
+</a></li>
+<li><a href="https://plus.google.com/u/1/108967384991768947849/posts/P2q82aYN7do">Google Play Services 4.0 
+</a></li>
+</ul>
+</div>
+
+<div class="col-8" style="margin-right:0">
+<h3>Blog</h3>
+
+<ul>
+  <li><a href="http://android-developers.blogspot.hk/2013/10/android-44-kitkat-and-updated-developer.html">Android 4.4 KitKat and Updated Developer Tools</a></li>
+  <li><a href="http://android-developers.blogspot.hk/2013/10/google-play-services-40.html">Google Play Services 4.0</a></li>
+  <li><a href="http://android-developers.blogspot.hk/2013/10/making-your-app-content-more-accessible.html">Making your App Content more Accessible from Googl...</a></li>
+  <li><a href="http://android-developers.blogspot.hk/2013/10/getting-your-sms-apps-ready-for-kitkat.html">Getting Your SMS Apps Ready for KitKat</a></li>
+</ul>
+</div>
+
+</div><!-- /MAIN CONTENT 'wrap' -->
+</body>
+</html>
+
+
+
diff --git a/docs/html/design/media/progress_download.png b/docs/html/design/media/progress_download.png
index 5c9e556..5765095 100644
--- a/docs/html/design/media/progress_download.png
+++ b/docs/html/design/media/progress_download.png
Binary files differ
diff --git a/docs/html/develop/index.jd b/docs/html/develop/index.jd
index 61a98b7..3f88b9d 100644
--- a/docs/html/develop/index.jd
+++ b/docs/html/develop/index.jd
@@ -3,6 +3,7 @@
 header.hide=1
 carousel=1
 tabbedList=1
+excludeFromSuggestions=true
 @jd:body
 
 <style>
diff --git a/docs/html/distribute/googleplay/edu/index.jd b/docs/html/distribute/googleplay/edu/index.jd
index 7a16bfd..487028f 100644
--- a/docs/html/distribute/googleplay/edu/index.jd
+++ b/docs/html/distribute/googleplay/edu/index.jd
@@ -19,7 +19,7 @@
     teacher-approved, educational apps and videos on Play Store. Teachers can filter
     content by subject matter, grade and other criteria. Bulk purchase and instant
     distribution let educators bring your apps directly to classrooms and schools.</p>
-    <p>If you have an educational app, be a part of Google Play for Education.</p>
+    <p>If you have an educational app, join Google Play for Education.</p>
     <p><a class="button" href="{@docRoot}distribute/googleplay/edu/about.html">Learn More</a></p>
   </div>
 </div>
diff --git a/docs/html/google/gcm/adv.jd b/docs/html/google/gcm/adv.jd
index 567b12c..245467f 100644
--- a/docs/html/google/gcm/adv.jd
+++ b/docs/html/google/gcm/adv.jd
@@ -96,7 +96,7 @@
 will get a <code>NotRegistered</code> error. See <a href="#unreg">
 How Unregistration Works</a> for more information.</p>
 <p>Although is not possible to track the status of each individual message, the
-Google APIs Console stats are broken down by messages sent to device, messages
+Google Cloud Console stats are broken down by messages sent to device, messages
 collapsed, and messages waiting for delivery.</p>
 
 <h2 id="throttling">Throttling</h2>
@@ -312,14 +312,10 @@
 <p>GCM will store up to 100 non-collapsible messages. After that, all messages
 are discarded from GCM, and a new message is created that tells the client how
 far behind it is. The message is delivered through a regular
-<code>com.google.android.c2dm.intent.RECEIVE</code> intent, with the following
-extras:</p>
-<ul>
-  <li> <code>message_type</code>&mdash;The value is always the string
-&quot;deleted_messages&quot;.</li>
-  <li><code>total_deleted</code>&mdash;The value  is a string with the number of
-deleted messages.</li>
-</ul>
+<code>com.google.android.c2dm.intent.RECEIVE</code> intent with the
+extra <code>message_type</code>, for which the value is always the string
+&quot;deleted_messages&quot;.</p>
+
 <p>The application should respond by syncing with the server to recover the
 discarded messages. </p>
 
diff --git a/docs/html/google/gcm/client.jd b/docs/html/google/gcm/client.jd
index df357a2..ee764ef 100644
--- a/docs/html/google/gcm/client.jd
+++ b/docs/html/google/gcm/client.jd
@@ -416,15 +416,18 @@
         }
     }.execute(null, null, null);
     ...
-    /**
-     * Sends the registration ID to your server over HTTP, so it can use GCM/HTTP
-     * or CCS to send messages to your app. Not needed for this demo since the
-     * device sends upstream messages to a server that echoes back the message
-     * using the 'from' address in the message.
-     */
-    private void sendRegistrationIdToBackend() {
-      // Your implementation here.
-    }
+}</pre>
+
+<p>Once you've received your registration ID, send it to your server:</p>
+<pre>
+/**
+ * Sends the registration ID to your server over HTTP, so it can use GCM/HTTP
+ * or CCS to send messages to your app. Not needed for this demo since the
+ * device sends upstream messages to a server that echoes back the message
+ * using the 'from' address in the message.
+ */
+private void sendRegistrationIdToBackend() {
+    // Your implementation here.
 }</pre>
 
 <p>After registering, the app calls {@code storeRegistrationId()} to store the
@@ -660,4 +663,3 @@
 <p class="note"><strong>Note:</strong> Stats on the Google API Console are not
 enabled for GCM. You must use the <a href="http://play.google.com/apps/publish">Developer Console</a>.</p>
 
-
diff --git a/docs/html/google/gcm/gcm.jd b/docs/html/google/gcm/gcm.jd
index 3c80b5f..88bf659 100644
--- a/docs/html/google/gcm/gcm.jd
+++ b/docs/html/google/gcm/gcm.jd
@@ -104,7 +104,7 @@
     <th colspan="2">Credentials</th>
   </tr>
   <tr>
-    <td><strong>Sender ID</strong></td>
+    <td id="senderid"><strong>Sender ID</strong></td>
     <td>A project number you acquire from the API console, as described in
 <a href="gs.html#create-proj">Getting Started</a>. The sender
 ID is used in the <a href="#register">registration process</a> to identify a
@@ -140,7 +140,7 @@
 account if the device is running a version lower than Android 4.0.4.</td>
   </tr>
   <tr>
-    <td><strong>Sender Auth Token</strong></td>
+    <td id="apikey"><strong>Sender Auth Token</strong></td>
     <td>An API key that is saved on the 3rd-party application
 server that gives the application server authorized access to Google services.
 The API key is included in the header of POST requests  that send messages.</td>
diff --git a/docs/html/google/gcm/gs.jd b/docs/html/google/gcm/gs.jd
index f6b7ebe..2a2c1c9 100644
--- a/docs/html/google/gcm/gs.jd
+++ b/docs/html/google/gcm/gs.jd
@@ -18,7 +18,8 @@
 <h2>See Also</h2>
 
 <ol class="toc">
-<li><a href="https://code.google.com/apis/console">Google APIs Console page</a></li>
+<li><a href="https://cloud.google.com/console">Google Cloud Console</a></li>
+<li><a href="https://developers.google.com/console/help/new/">Google Cloud Console Help</a></li>
 <li><a href="https://services.google.com/fb/forms/gcm/" class="external-link" target="_android">CCS and User Notifications Signup Form</a></li>
 </ol>
 
@@ -32,66 +33,53 @@
 <a href="{@docRoot}reference/com/google/android/gms/gcm/GoogleCloudMessaging.html">
 {@code GoogleCloudMessaging}</a> methods.</p>
 
-
 <h2 id="create-proj">Creating a Google API project</h2>
 <p>To create a Google API project:</p>
 <ol>
-  <li>Open the <a href="https://code.google.com/apis/console">Google APIs Console page</a>.
+  <li>Open the <a href="https://cloud.google.com/console">Google Cloud Console</a>.
   </li>
-  <li>If you haven't created an API project yet, this page will prompt you to do so:
-  <p><img src="{@docRoot}images/gcm/gcm-create-api-proj.png" class="screenshot" /></p>
-<p class="note"><strong>Note:</strong> If you already have existing projects,
-the first page you see will be the <strong>Dashboard</strong> page. From there
-you can create a new project by opening the project drop-down menu (upper left corner)
-and choosing <strong>Other projects > Create</strong>.</p></li>
-  <li> Click <strong>Create project</strong>.
-    Your browser URL will change to something like:</li>
+  <li>If you haven't created an API project yet, click <strong>Create Project</strong>.</li>
 
-<pre> https://code.google.com/apis/console/#project:<strong>4815162342</strong></pre>
+ <li>Supply a project name and click <strong>Create</strong>.
 
-  <li> Take note of the value after <code>#project:</code> (4815162342 in this
-example). This is your project number, and it will be used later on as the GCM sender ID.</li>
+<p>Once the project has been created, a page appears that displays your project ID and
+project number. For example, <strong>Project Number: 670330094152</strong>.</p></li>
+
+  <li>Copy down your project number. You will use it later on as the
+  <a href="{@docRoot}google/gcm/gcm.html#senderid">GCM sender ID</a>.</li>
   
 </ol>
 <h2 id="gcm-service">Enabling the GCM Service</h2>
 <p>To enable the GCM service:</p>
 <ol>
-  <li> In the main Google APIs Console page, select <strong>Services</strong>.</li>
-  <li>Turn the <strong>Google Cloud Messaging</strong> toggle to ON.</li>
-  <li>In the Terms of Service page, accept the terms.
-  </li>
+  <li>In the sidebar on the left, select <strong>APIs &amp; auth</strong>. </li>
+  <li>In the displayed list of APIs, turn the <strong>Google Cloud Messaging for Android
+  </strong> toggle to ON.</li>
+
 </ol>
 <h2 id="access-key">Obtaining an API Key</h2>
 <p>To obtain an API  key:</p>
 <ol>
-  <li> In the main Google APIs Console page, select <strong>API Access</strong>.
-You will see a screen that resembles the following:</li>
+ <li>In the sidebar on the left, select <strong>APIs &amp; auth > Registered apps</strong>.</li>
+<li>Click <strong>Register app</strong>. </li>
 
+<li>In the <strong>Name</strong> field, type your app's name.</li>
+<li>Click <strong>Android > Accessing APIs directly from Android</strong>.</li>
+<li>Under <strong>Android identification</strong>, type the package name for your app.</li>
+<li>Enter an SHA1 fingerprint. To get this value, follow the instructions in the
+<a href="http://developers.google.com/console/help/new/#installedapplications">console
+help</a>.</li>
+<li>Click <strong>Register</strong>.</li>
 
-<img src="{@docRoot}images/gcm/gcm-api-access.png" style="width:400px;padding:4px;">
+<li>In the new page, open the <strong>Android Key</strong> section and copy the
+<a href="{@docRoot}google/gcm/gcm.html#apikey">API key</a>.
+You will need the API key later on to perform authentication in your application server.</li>
 
-  <li>Click  <strong>Create new Server key</strong>. Either a server key or a
-browser key should work. The advantage to using a server key is that it allows
-you to whitelist IP addresses. The following screen appears:</li>
-
-
-<img src="{@docRoot}images/gcm/gcm-config-server-key.png" style="width:400px;padding:4px;">
-
-  
-  <li>Click <strong>Create</strong>:</li>
-  
-
-<img src="{@docRoot}images/gcm/gcm-api-key.png" style="width:400px;padding:4px;">
-
-
-
-</ol>
-<p> Take note of the <strong>API key</strong> value (<code>YourKeyWillBeShownHere</code>)
-in this example, as it will be used later on.</p>
 <p class="note"><strong>Note:</strong> If you need to rotate the key, click
-<strong>Generate new key</strong>. A new key  will be created while the old one
-will still be active for up to 24 hours. If you want to get rid of the old key
-immediately (for example, if you feel it was compromised), click <strong>Delete key</strong>.</p>
+the "recycle key" icon. A new key  will be created. If you think the key has been compromised
+and you want to delete it immediately, you can accomplish this by deleting the app from
+the console. Then create a new entry for the app with the same SHA1 and package name.</p>
+</ol>
 
 <h2 id="next">Next Steps</h2>
 
@@ -113,4 +101,3 @@
 on a device. See <a href="client.html">Implementing GCM Client</a> for more information.</li>
 </ol>
 
-
diff --git a/docs/html/google/gcm/server.jd b/docs/html/google/gcm/server.jd
index b5e6b48..7ba1bd5 100644
--- a/docs/html/google/gcm/server.jd
+++ b/docs/html/google/gcm/server.jd
@@ -134,7 +134,7 @@
   <li>When the device is online, Google sends the message to the device.</li>
   <li>On the device, the system broadcasts the message to the specified Android
 application via Intent broadcast with proper permissions, so that only the targeted
-ndroid application gets the message. This wakes the Android application up.
+Android application gets the message. This wakes the Android application up.
 The Android application does not need to be running beforehand to receive the message.</li>
   <li>The Android application processes the message. </li>
 </ol>
@@ -146,7 +146,7 @@
 <p>Required. When your app server sends a message in GCM, it must specify a target.</p>
 <p>For HTTP you must specify the target as one of:</p>
 <ul>
-<li><code>registration_ids</code>: For sending to 1 more more devices (up to 1000).
+<li><code>registration_ids</code>: For sending to 1 or more devices (up to 1000).
 When you send a message to multiple registration IDs, that is called a multicast message.</li>
 <li><code>notification_key</code>: For sending to multiple devices owned by a single user.</li>
 </ul>
diff --git a/docs/html/google/play/billing/v2/api.jd b/docs/html/google/play/billing/v2/api.jd
index 7e386a2..9501555 100644
--- a/docs/html/google/play/billing/v2/api.jd
+++ b/docs/html/google/play/billing/v2/api.jd
@@ -32,14 +32,6 @@
 asynchronous and uses service messages sent as broadcast intents, so
 it is more complicated than Version 3. </p>
 
-<p>Version 2 supports both unmanaged and managed products, as well as supports
-subscriptions, where Version 3 does not yet offer support for subscriptions. If
-you want to sell subscriptions in your app, you should implement In-app Billing
-Version 2, rather than Version 3. </p>
-
-<p>If you do not need to sell subscriptions, you
-should implement In-app Billing Version 3 instead.</p>
-
 <h2 id="billing-types">Product Types</h2>
 
 <p>In-app Billing Version supports three different product types
@@ -500,11 +492,8 @@
   <li>In-app billing can be implemented only in applications that you publish through Google
   Play.</li>
   <li>You must have a Google Wallet Merchant account to use Google Play In-app Billing.</li>
-  <li>In-app billing requires version 2.3.4 (or higher) of the Android Market application.
-  To support subscriptions, version 3.5 or higher of the Google Play app is required. On devices
-  running Android 3.0, version 5.0.12 (or higher) of the MyApps application is required.</li>
-  <li>An application can use in-app billing only if the device is running Android 1.6 (API level 4)
-  or higher.</li>
+  <li>To support subscriptions, version 3.5 or higher of the Google Play app is required. </li>
+  <li>In-app Billing requires Android 1.6 (API level 4) or higher.</li>
   <li>You can use in-app billing to sell only digital content. You cannot use in-app billing to sell
   physical goods, personal services, or anything that requires physical delivery.</li>
   <li>Google Play does not provide any form of content delivery. You are responsible for
diff --git a/docs/html/guide/components/intents-common.jd b/docs/html/guide/components/intents-common.jd
new file mode 100644
index 0000000..f09ef9f
--- /dev/null
+++ b/docs/html/guide/components/intents-common.jd
@@ -0,0 +1,1312 @@
+page.title=Common Intents
+page.tags="IntentFilter"
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+  <h2>In this document
+    <a href="#" onclick="hideNestedItems('#tocIntents',this);return false;" class="header-toggle">
+        <span class="more">show more</span>
+        <span class="less" style="display:none">show less</span></a></h2>
+
+<ol id="tocIntents" class="hide-nested">
+  <li><a href="#Camera">Camera</a>
+    <ol>
+      <li><a href="#ImageCapture">Capture a picture or video and return it</a></li>
+    </ol>
+  </li>
+  <li><a href="#Contacts">Contacts/People App</a>
+    <ol>
+      <li><a href="#PickContact">Select a contact</a></li>
+      <li><a href="#PickContactDat">Select specific contact data</a></li>
+      <li><a href="#ViewContact">View a contact</a></li>
+      <li><a href="#EditContact">Edit an existing contact</a></li>
+      <li><a href="#InsertContact">Insert a contact</a></li>
+    </ol>
+  </li>
+  <li><a href="#Email">Email</a>
+    <ol>
+      <li><a href="#ComposeEmail">Compose an email with optional attachments</a></li>
+    </ol>
+  </li>
+  <li><a href="#Storage">File Storage</a>
+    <ol>
+      <li><a href="#GetFile">Retrieve a specific type of file</a></li>
+      <li><a href="#OpenFile">Open a specific type of file</a></li>
+    </ol>
+  </li>
+  <li><a href="#Maps">Maps</a>
+    <ol>
+      <li><a href="#ViewMap">Show a location on a map</a></li>
+    </ol>
+  </li>
+  <li><a href="#Music">Music or Video</a>
+    <ol>
+      <li><a href="#PlayMedia">Play a media file</a></li>
+    </ol>
+  </li>
+  <li><a href="#Phone">Phone</a>
+    <ol>
+      <li><a href="#DialPhone">Initiate a phone call</a></li>
+    </ol>
+  </li>
+  <li><a href="#Settings">Settings</a>
+    <ol>
+      <li><a href="#OpenSettings">Open a specific section of Settings</a></li>
+    </ol>
+  </li>
+  <li><a href="#Messaging">Text Messaging</a>
+    <ol>
+      <li><a href="#SendMessage">Compose an SMS/MMS message with attachment</a></li>
+    </ol>
+  </li>
+  <li><a href="#Browser">Web Browser</a>
+    <ol>
+      <li><a href="#ViewUrl">Load a web URL</a></li>
+      <li><a href="#SearchWeb">Perform a web search</a></li>
+    </ol>
+  </li>
+</ol>
+
+  <h2>See also</h2>
+  <ol>
+    <li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
+Filters</a></li>
+  </ol>
+</div>
+</div>
+
+
+<p>An intent allows you to start an activity in another app by describing a simple
+action you'd like to perform (such as "view a map" or "take a picture")
+in an {@link android.content.Intent} object. This type of intent is
+called an <em>implicit</em> intent because it does not specify the app component
+to start, but instead specifies an <em>action</em> and provides some
+<em>data</em> with which to perform the action.</p>
+
+<p>When you call
+{@link android.content.Context#startActivity startActivity()} or
+{@link android.app.Activity#startActivityForResult startActivityForResult()} and pass it an
+implicit intent, the system <a href="{@docRoot}guide/components/intents-filters.html#Resolution"
+>resolves the intent</a> to an app that can handle the intent
+and starts its corresponding {@link android.app.Activity}. If there's more than one app
+that can handle the intent, the system presents the user with a dialog to pick which app
+to use.</p>
+
+<p>This page describes several implicit intents that you can use to perform common actions,
+organized by the type of app that handles the intent. Each section also shows how you can
+create an <a href="{@docRoot}guide/components/intents-filters.html#Receiving">intent filter</a> to
+advertise your app's ability to perform the same action.</p>
+
+<p class="caution"><strong>Caution:</strong> If there are no apps on the device that can receive
+the implicit intent, your app will crash when it calls {@link android.content.Context#startActivity
+startActivity()}. To first verify that an app exists to receive the intent, call {@link
+android.content.Intent#resolveActivity resolveActivity()} on your {@link android.content.Intent}
+object. If the result is non-null, there is at least one app that can handle the intent and
+it's safe to call {@link android.content.Context#startActivity startActivity()}. If the result is
+null, you should not use the intent and, if possible, you should disable the feature that invokes
+the intent.</p>
+
+
+<p>If you're not familiar with how to create intents or intent filters, you should first read
+<a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent Filters</a>.</p>
+
+
+
+
+
+<h2 id="Camera">Camera</h2>
+
+
+
+<h3 id="ImageCapture">Capture a picture or video and return it</h3>
+
+<p>To open a camera app and receive the resulting photo or video, use the {@link
+android.provider.MediaStore#ACTION_IMAGE_CAPTURE} or {@link
+android.provider.MediaStore#ACTION_VIDEO_CAPTURE} action. Also specify the URI location where you'd
+like the camera to save the photo or video, in the {@link android.provider.MediaStore#EXTRA_OUTPUT}
+extra.</p>
+
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.provider.MediaStore#ACTION_IMAGE_CAPTURE} or<br>
+    {@link android.provider.MediaStore#ACTION_VIDEO_CAPTURE}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>None</dd>
+
+<dt><b>Extras</b></dt>
+<dd>
+    <dl>
+      <dt>{@link android.provider.MediaStore#EXTRA_OUTPUT}</dt>
+      <dd>The URI location where the camera app should save the photo or
+      video file (as a {@link android.net.Uri} object).</dd>
+    </dl>
+</dd>
+</dl>
+
+<p>When the camera app successfully returns
+focus to your activity (your app receives the {@link android.app.Activity#onActivityResult
+onActivityResult()} callback), you can access the photo or video at the URI you specified
+with the {@link android.provider.MediaStore#EXTRA_OUTPUT} value.</p>
+
+<p class="note"><strong>Note:</strong> When you use {@link
+android.provider.MediaStore#ACTION_IMAGE_CAPTURE} to capture a photo, the camera may also return a
+downscaled copy (a thumbnail) of the photo in the result {@link
+android.content.Intent}, saved as a {@link android.graphics.Bitmap} in an extra field named
+<code>"data"</code>.</p>
+
+
+<p><b>Example intent:</b></p>
+<pre>
+static final int REQUEST_IMAGE_CAPTURE = 1;
+static final Uri mLocationForPhotos;
+
+public void capturePhoto(String targetFilename) {
+    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+    intent.putExtra(MediaStore.EXTRA_OUTPUT,
+            Uri.withAppendedPath(mLocationForPhotos, targetFilename);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivityForResult(intent, REQUEST_IMAGE_CAPTURE);
+    }
+}
+
+&#64;Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
+        Bitmap thumbnail = data.getParcelable("data");
+        // Do other work with full size photo saved in mLocationForPhotos
+        ...
+    }
+}
+</pre>
+
+<p>For more information about how to use this intent to capture a photo, including
+how to create an appropriate {@link android.net.Uri} for the output location, read
+<a href="{@docRoot}training/camera/photobasics.html">Taking Photos Simply</a> or
+<a href="{@docRoot}training/camera/videobasics.html">Taking Videos Simply</a>.</p>
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.media.action.IMAGE_CAPTURE" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+<p>When handling this intent, your activity should check for the {@link
+android.provider.MediaStore#EXTRA_OUTPUT} extra in the incoming {@link android.content.Intent},
+then save the captured image or video at the location specified by that extra and call {@link
+android.app.Activity#setResult(int,Intent) setResult()} with an
+{@link android.content.Intent} that includes a compressed thumbnail
+in an extra named <code>"data"</code>.</p>
+
+
+
+
+<h2 id="Contacts">Contacts/People App</h2>
+
+
+<h3 id="PickContact">Select a contact</h3>
+
+<p>To have the user select a contact and provide your app access to all the contact information,
+use the {@link android.content.Intent#ACTION_PICK} action and specify the MIME type to
+{@link android.provider.ContactsContract.Contacts#CONTENT_TYPE
+Contacts.CONTENT_TYPE}.</p>
+
+<p>The result {@link android.content.Intent} delivered to your {@link
+android.app.Activity#onActivityResult onActivityResult()} callback contains the
+<code>content:</code> URI pointing to the selected contact. The response grants
+your app temporary permissions to read that contact using the <a
+href="{@docRoot}guide/topics/providers/contacts-provider.html">Contacts Provider</a> API even if
+your app does not include the {@link android.Manifest.permission#READ_CONTACTS} permission.</p>
+
+<p class="note"><strong>Tip:</strong> If you need access to only a specific piece of contact
+information, such as a phone number or email address, instead see the next section about how to
+<a href="#PickContactData">select specific contact data</a>.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_PICK}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>{@link android.provider.ContactsContract.Contacts#CONTENT_TYPE
+Contacts.CONTENT_TYPE}
+</dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+static final int REQUEST_SELECT_CONTACT = 1;
+
+public void selectContact() {
+    Intent intent = new Intent(Intent.ACTION_PICK);
+    intent.setType(ContactsContract.Contacts.CONTENT_TYPE);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivityForResult(intent, REQUEST_SELECT_CONTACT);
+    }
+}
+
+&#64;Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == REQUEST_SELECT_CONTACT && resultCode == RESULT_OK) {
+        Uri contactUri = data.getData();
+        // Do something with the selected contact at contactUri
+        ...
+    }
+}
+</pre>
+
+<p>For information about how to retrieve contact details once you have the contact URI,
+read <a href="{@docRoot}training/contacts-provider/retrieve-details.html">Retrieving Details
+for a Contact</a>. Remember, when you retrieve the contact URI with the above intent, you
+<strong>do not</strong> need the {@link android.Manifest.permission#READ_CONTACTS} permission
+to read details for that contact.</p>
+
+
+
+
+<h3 id="PickContactDat">Select specific contact data</h3>
+
+<p>To have the user select a specific piece of information from a contact, such as
+a phone number, email address, or other data type, use the
+{@link android.content.Intent#ACTION_PICK} action and specify the MIME type to one
+of the content types listed below, such as
+{@link android.provider.ContactsContract.CommonDataKinds.Phone#CONTENT_TYPE
+CommonDataKinds.Phone.CONTENT_TYPE} to get the contact's phone number.</p>
+
+<p>If you need to retrieve only one type of data from a contact, this technique with a
+{@code CONTENT_TYPE} from the
+{@link android.provider.ContactsContract.CommonDataKinds} classes is more efficient than
+using the {@link android.provider.ContactsContract.Contacts#CONTENT_TYPE
+Contacts.CONTENT_TYPE} (as shown in the previous section) because the result provides you direct
+access to the desired data without requiring you to perform a more complex query to <a
+href="{@docRoot}guide/topics/providers/contacts-provider.html">Contacts Provider</a>.</p>
+
+<p>The result {@link android.content.Intent} delivered to your {@link
+android.app.Activity#onActivityResult onActivityResult()} callback contains the
+<code>content:</code> URI pointing to the selected contact data. The response grants
+your app temporary permissions to read that contact data even if your app does
+not include the {@link android.Manifest.permission#READ_CONTACTS} permission.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_PICK}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>
+    <dl>
+      <dt>{@link android.provider.ContactsContract.CommonDataKinds.Phone#CONTENT_TYPE
+CommonDataKinds.Phone.CONTENT_TYPE}</dt>
+      <dd>Pick from contacts with a phone number.</dd>
+      <dt>{@link android.provider.ContactsContract.CommonDataKinds.Email#CONTENT_TYPE
+CommonDataKinds.Email.CONTENT_TYPE}</dt>
+      <dd>Pick from contacts with an email address.</dd>
+      <dt>{@link android.provider.ContactsContract.CommonDataKinds.StructuredPostal#CONTENT_TYPE
+CommonDataKinds.StructuredPostal.CONTENT_TYPE}</dt>
+      <dd>Pick from contacts with a postal address.</dd>
+    </dl>
+  <p>Or one of many other {@code CONTENT_TYPE} values
+  under {@link android.provider.ContactsContract}.</p>
+</dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+static final int REQUEST_SELECT_PHONE_NUMBER = 1;
+
+public void selectContact() {
+    // Start an activity for the user to pick a phone number from contacts
+    Intent intent = new Intent(Intent.ACTION_PICK);
+    intent.setType(CommonDataKinds.Phone.CONTENT_TYPE);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivityForResult(intent, REQUEST_SELECT_PHONE_NUMBER);
+    }
+}
+
+&#64;Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == REQUEST_SELECT_PHONE_NUMBER && resultCode == RESULT_OK) {
+        // Get the URI and query the content provider for the phone number
+        Uri contactUri = data.getData();
+        String[] projection = new String[]{CommonDataKinds.Phone.NUMBER};
+        Cursor cursor = getContentResolver().query(contactUri, projection,
+                null, null, null);
+        // If the cursor returned is valid, get the phone number
+        if (cursor != null && cursor.moveToFirst()) {
+            int numberIndex = cursor.getColumnIndex(CommonDataKinds.Phone.NUMBER);
+            String number = cursor.getString(numberIndex);
+            // Do something with the phone number
+            ...
+        }
+    }
+}
+</pre>
+
+
+
+
+
+<h3 id="ViewContact">View a contact</h3>
+
+<p>To display the details for a known contact, use the {@link android.content.Intent#ACTION_VIEW}
+action and specify the contact with a {@code content:} URI as the intent data.</p>
+
+<p>There are primarily two ways to initially retrieve the contact's URI:</p>
+<ul>
+  <li>Use the contact URI returned by the {@link android.content.Intent#ACTION_PICK},
+  shown in the previous section (this does not require any app permissions).</li>
+  <li>Access the list of all contacts directly, as described in <a
+  href="{@docRoot}training/contacts-provider/retrieve-names.html">Retrieving a List of
+  Contacts</a> (this requires the {@link android.Manifest.permission#READ_CONTACTS}
+  permission).</li>
+</ul>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_VIEW}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>{@code content:&lt;URI>}</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>None. The type is inferred from contact URI.
+</dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void viewContact(Uri contactUri) {
+    Intent intent = new Intent(Intent.ACTION_VIEW, contactUri);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+
+<h3 id="EditContact">Edit an existing contact</h3>
+
+<p>To edit a known contact, use the {@link android.content.Intent#ACTION_EDIT}
+action, specify the contact with a {@code content:} URI
+as the intent data, and include any known contact information in extras specified by
+constants in {@link android.provider.ContactsContract.Intents.Insert}.</p>
+
+<p>There are primarily two ways to initially retrieve the contact URI:</p>
+<ul>
+  <li>Use the contact URI returned by the {@link android.content.Intent#ACTION_PICK},
+  shown in the previous section (this does not require any app permissions).</li>
+  <li>Access the list of all contacts directly, as described in <a
+  href="{@docRoot}training/contacts-provider/retrieve-names.html">Retrieving a List of
+  Contacts</a> (this requires the {@link android.Manifest.permission#READ_CONTACTS}
+  permission).</li>
+</ul>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_EDIT}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>{@code content:&lt;URI>}</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>The type is inferred from contact URI.
+</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>One or more of the extras defined in {@link android.provider.ContactsContract.Intents.Insert}
+so you can populate fields of the contact details.
+</dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void editContact(Uri contactUri, String email) {
+    Intent intent = new Intent(Intent.ACTION_EDIT);
+    intent.setDataAndType(contactUri, Contacts.CONTENT_TYPE);
+    intent.putExtra(Intents.Insert.EMAIL, email);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+<p>For more information about how to edit a contact, read <a
+href="{@docRoot}training/contacts-provider/modify-data.html">Modifying
+Contacts Using Intents</a>.</p>
+
+
+
+
+<h3 id="InsertContact">Insert a contact</h3>
+
+<p>To insert a new contact, use the {@link android.content.Intent#ACTION_INSERT} action,
+specify {@link android.provider.ContactsContract.Contacts#CONTENT_TYPE Contacts.CONTENT_TYPE} as
+the MIME type, and include any known contact information in extras specified by
+constants in {@link android.provider.ContactsContract.Intents.Insert}.
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_INSERT}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>{@link android.provider.ContactsContract.Contacts#CONTENT_TYPE Contacts.CONTENT_TYPE}</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>One or more of the extras defined in {@link android.provider.ContactsContract.Intents.Insert}.
+</dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void insertContact(String name, String email) {
+    Intent intent = new Intent(Intent.ACTION_INSERT);
+    intent.setType(Contacts.CONTENT_TYPE);
+    intent.putExtra(Intents.Insert.NAME, name);
+    intent.putExtra(Intents.Insert.EMAIL, email);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+<p>For more information about how to insert a contact, read <a
+href="{@docRoot}training/contacts-provider/modify-data.html">Modifying
+Contacts Using Intents</a>.</p>
+
+
+
+
+
+
+
+<h2 id="Email">Email</h2>
+
+
+<h3 id="ComposeEmail">Compose an email with optional attachments</h3>
+
+
+<p>To compose an email, use one of the below actions based on whether you'll include attachments,
+and include email details such as the recipient and subject using the extra keys listed below.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_SENDTO} (for no attachment) or<br>
+    {@link android.content.Intent#ACTION_SEND} (for one attachment) or<br>
+    {@link android.content.Intent#ACTION_SEND_MULTIPLE} (for multiple attachments)</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>
+  <dl>
+    <dt>{@link org.apache.http.protocol.HTTP#PLAIN_TEXT_TYPE} ("text/plain")
+    <dt><code>"*/*"</code>
+  </dl>
+</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>
+  <dl>
+    <dt>{@link android.content.Intent#EXTRA_EMAIL Intent.EXTRA_EMAIL}</dt>
+      <dd>A string array of all "To" recipient email addresses.</dd>
+    <dt>{@link android.content.Intent#EXTRA_CC Intent.EXTRA_CC}</dt>
+      <dd>A string array of all "CC" recipient email addresses.</dd>
+    <dt>{@link android.content.Intent#EXTRA_BCC Intent.EXTRA_BCC}</dt>
+      <dd>A string array of all "BCC" recipient email addresses.</dd>
+    <dt>{@link android.content.Intent#EXTRA_SUBJECT Intent.EXTRA_SUBJECT}</dt>
+      <dd>A string with the email subject.</dd>
+    <dt>{@link android.content.Intent#EXTRA_TEXT Intent.EXTRA_TEXT}</dt>
+      <dd>A string with the body of the email.</dd>
+    <dt>{@link android.content.Intent#EXTRA_STREAM Intent.EXTRA_STREAM}</dt>
+      <dd>A {@link android.net.Uri} pointing to the attachment. If using the
+        {@link android.content.Intent#ACTION_SEND_MULTIPLE} action, this should instead
+        be an {@link java.util.ArrayList} containing multiple {@link android.net.Uri} objects.</dd>
+  </dl>
+</dd>
+
+</dl>
+
+
+<p><b>Example intent:</b></p>
+<pre>
+public void composeEmail(String[] addresses, String subject, Uri attachment) {
+    Intent intent = new Intent(Intent.ACTION_SEND);
+    intent.setType("*/*");
+    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
+    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
+    intent.putExtra(Intent.EXTRA_STREAM, attachment);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+<p>If you want to ensure that your intent is handled only by an email app (and not other
+text messaging or social apps), then use the {@link android.content.Intent#ACTION_SENDTO} action
+and include the {@code "mailto:"} data scheme. For example:</p>
+
+<pre>
+public void composeEmail(String[] addresses, String subject) {
+    Intent intent = new Intent(Intent.ACTION_SENDTO);
+    intent.setData(Uri.parse("mailto:")); // only email apps should handle this
+    intent.putExtra(Intent.EXTRA_EMAIL, addresses);
+    intent.putExtra(Intent.EXTRA_SUBJECT, subject);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.SEND" />
+        &lt;data android:type="*/*" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.SENDTO" />
+        &lt;data android:scheme="mailto" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="Storage">File Storage</h2>
+
+
+
+<h3 id="GetFile">Retrieve a specific type of file</h3>
+
+<p>To request that the user select a file such as a document or photo and return a reference to
+your app, use the {@link android.content.Intent#ACTION_GET_CONTENT} action and specify your desired
+MIME type. The file reference returned to your app is transient to your activity's current
+lifecycle, so if you want to access it later you must import a copy that you can read later.
+This intent also allows the user to create a new file in the process (for
+example, instead of selecting an existing photo, the user can capture a new photo with the camera).
+</p>
+
+<p>The result intent delivered to your {@link android.app.Activity#onActivityResult
+onActivityResult()} method includes data with a URI pointing to the file.
+The URI could be anything, such as an {@code http:} URI, {@code file:} URI, or {@code content:}
+URI. However, if you'd like to restrict selectable files to only those that are accessible
+from a content provider (a {@code content:} URI) and that are available as a file stream with {@link
+android.content.ContentResolver#openFileDescriptor openFileDescriptor()}, you should add
+the {@link android.content.Intent#CATEGORY_OPENABLE} category to your intent.</p>
+
+<p>On Android 4.3 (API level 18) and higher,
+you can also allow the user to select multiple files by adding
+{@link android.content.Intent#EXTRA_ALLOW_MULTIPLE} to the intent, set to {@code true}.
+You can then access each of the selected files in a {@link android.content.ClipData}
+object returned by {@link android.content.Intent#getClipData()}.</p>
+
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_GET_CONTENT}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>The MIME type corresponding to the file type the user should select.
+</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>
+  <dl>
+    <dt>{@link android.content.Intent#EXTRA_ALLOW_MULTIPLE}
+      <dd>A boolean declaring whether the user can select more than one file at a time.
+      </dd>
+    <dt>{@link android.content.Intent#EXTRA_LOCAL_ONLY}
+      <dd>A boolean that declares whether the returned file must be available directly from
+      the device, rather than requiring a download from a remote service.
+      </dd>
+  </dl>
+</dd>
+
+<dt><b>Category</b> (optional)</dt>
+<dd>
+  <dl>
+    <dt>{@link android.content.Intent#CATEGORY_OPENABLE}</dt>
+      <dd>To return only "openable" files that can be represented as a file stream
+      with {@link android.content.ContentResolver#openFileDescriptor openFileDescriptor()}.</dd>
+  </dl>
+</dd>
+
+</dl>
+
+<p><b>Example intent to get a photo:</b></p>
+<pre>
+static final int REQUEST_IMAGE_GET = 1;
+
+public void selectImage() {
+    Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
+    intent.setType("image/*");
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivityForResult(intent, REQUEST_IMAGE_GET);
+    }
+}
+
+&#64;Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == REQUEST_IMAGE_GET && resultCode == RESULT_OK) {
+        Bitmap thumbnail = data.getParcelable("data");
+        Uri fullPhotoUri = data.getData();
+        // Do work with photo saved at fullPhotoUri
+        ...
+    }
+}
+</pre>
+
+<p><b>Example intent filter to return a photo:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.GET_CONTENT" />
+        &lt;data android:type="image/*" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+        &lt;!-- The OPENABLE category declares that the returned file is accessible
+             from a content provider that supports {@link android.provider.OpenableColumns}
+             and {@link android.content.ContentResolver#openFileDescriptor ContentResolver.openFileDescriptor()} -->
+        &lt;category android:name="android.intent.category.OPENABLE" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+
+
+
+
+
+<h3 id="OpenFile">Open a specific type of file</h3>
+
+<p>Instead of retrieving a copy of a file that you must import to your app
+(by using the {@link android.content.Intent#ACTION_GET_CONTENT} action), when running on Android
+4.4 or higher, you can instead request to <em>open</em> a file that's managed by another app by
+using the {@link android.content.Intent#ACTION_OPEN_DOCUMENT} action and specifying a MIME type.
+To also allow the user to instead create a new document that your app can write to, use the {@link
+android.content.Intent#ACTION_CREATE_DOCUMENT} action instead. For example, instead of
+selecting from existing PDF documents, the {@link android.content.Intent#ACTION_CREATE_DOCUMENT}
+intent allows users to select where they'd like to create a new document (within another app
+that manages the document's storage)&mdash;your app then receives the URI location of where it
+can write the new document.</p>
+
+<p>Whereas the intent delivered to your {@link android.app.Activity#onActivityResult
+onActivityResult()} method from the {@link android.content.Intent#ACTION_GET_CONTENT} action may
+return a URI of any type, the result intent from {@link android.content.Intent#ACTION_OPEN_DOCUMENT}
+and {@link android.content.Intent#ACTION_CREATE_DOCUMENT} always specify the chosen file as a {@code
+content:} URI that's backed by a {@link android.provider.DocumentsProvider}. You can open the
+file with {@link android.content.ContentResolver#openFileDescriptor openFileDescriptor()} and
+query its details using columns from {@link android.provider.DocumentsContract.Document}.</p>
+
+<p>The returned URI grants your app long-term read access to the file (also possibly
+with write access). So the {@link android.content.Intent#ACTION_OPEN_DOCUMENT} action is
+particularly useful (instead of using {@link android.content.Intent#ACTION_GET_CONTENT})
+when you want to read an existing file without making a copy into your app,
+or when you want to open and edit a file in place.</p>
+
+<p>You can also allow the user to select multiple files by adding
+{@link android.content.Intent#EXTRA_ALLOW_MULTIPLE} to the intent, set to {@code true}.
+If the user selects just one item, then you can retrieve the item from {@link
+android.content.Intent#getData()}. If the user selects more than one item, then {@link
+android.content.Intent#getData()} returns null and you must instead
+retrieve each item from a {@link android.content.ClipData}
+object that is returned by {@link android.content.Intent#getClipData()}.</p>
+
+<p class="note"><strong>Note:</strong> Your intent <strong>must</strong> specify a MIME type and
+<strong>must</strong> declare the {@link android.content.Intent#CATEGORY_OPENABLE} category. If
+appropriate, you can specify more than one MIME type by adding an array of MIME types with the
+{@link android.content.Intent#EXTRA_MIME_TYPES} extra&mdash;if you do so, you must set the
+primary MIME type in {@link android.content.Intent#setType setType()} to {@code "*/*"}.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_OPEN_DOCUMENT} or<br/>
+{@link android.content.Intent#ACTION_CREATE_DOCUMENT}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>The MIME type corresponding to the file type the user should select.
+</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>
+  <dl>
+    <dt>{@link android.content.Intent#EXTRA_MIME_TYPES}
+      <dd>An array of MIME types corresponding to the types of files your app is
+      requesting. When you use this extra, you must set the primary MIME type in
+      {@link android.content.Intent#setType setType()} to {@code "*/*"}.</dd>
+    <dt>{@link android.content.Intent#EXTRA_ALLOW_MULTIPLE}
+      <dd>A boolean that declares whether the user can select more than one file at a time.
+      </dd>
+    <dt>{@link android.content.Intent#EXTRA_TITLE}
+      <dd>For use with {@link android.content.Intent#ACTION_CREATE_DOCUMENT} to specify
+      an initial file name.
+      </dd>
+    <dt>{@link android.content.Intent#EXTRA_LOCAL_ONLY}
+      <dd>A boolean that declares whether the returned file must be available directly from
+      the device, rather than requiring a download from a remote service.
+      </dd>
+  </dl>
+</dd>
+
+<dt><b>Category</b></dt>
+<dd>
+  <dl>
+    <dt>{@link android.content.Intent#CATEGORY_OPENABLE}</dt>
+      <dd>To return only "openable" files that can be represented as a file stream
+      with {@link android.content.ContentResolver#openFileDescriptor openFileDescriptor()}.</dd>
+  </dl>
+</dd>
+
+</dl>
+
+<p><b>Example intent to get a photo:</b></p>
+<pre>
+static final int REQUEST_IMAGE_OPEN = 1;
+
+public void selectImage() {
+    Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+    intent.setType("image/*");
+    intent.addCategory(Intent.CATEGORY_OPENABLE);
+    // Only the system receives the ACTION_OPEN_DOCUMENT, so no need to test.
+    startActivityForResult(intent, REQUEST_IMAGE_OPEN);
+}
+
+&#64;Override
+protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+    if (requestCode == REQUEST_IMAGE_OPEN && resultCode == RESULT_OK) {
+        Uri fullPhotoUri = data.getData();
+        // Do work with full size photo saved at fullPhotoUri
+        ...
+    }
+}
+</pre>
+
+<p>Third party apps cannot actually respond to an intent with the
+{@link android.content.Intent#ACTION_OPEN_DOCUMENT} action. Instead, the system receives this
+intent and displays all the files available from various apps in a unified user interface.</p>
+
+<p>To provide your app's files in this UI and allow other apps to open them, you must implement
+a {@link android.provider.DocumentsProvider} and include an intent filter for
+{@link android.provider.DocumentsContract#PROVIDER_INTERFACE}
+({@code "android.content.action.DOCUMENTS_PROVIDER"}). For example:
+
+<pre>
+&lt;provider ...
+    android:grantUriPermissions="true"
+    android:exported="true"
+    android:permission="android.permission.MANAGE_DOCUMENTS">
+    &lt;intent-filter>
+        &lt;action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+    &lt;/intent-filter>
+&lt;/provider>
+</pre>
+
+<p>For more information about how to make the files managed by your app openable from other apps,
+read the <a href="{@docRoot}guide/topics/providers/document-provider.html">Storage Access
+Framework</a> guide.</p>
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="Maps">Maps</h2>
+
+<h3 id="ViewMap">Show a location on a map</h3>
+
+<p>To open a map, use the {@link android.content.Intent#ACTION_VIEW} action and specify
+the location information in the intent data with one of the schemes defined below.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_VIEW}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>
+<dl>
+  <dt><code>geo:<em>latitude</em>,<em>longitude</em></code></dt>
+    <dd>Show the map at the given longitude and latitude.
+      <p>Example: <code>"geo:47.6,-122.3"</code>
+    </dd>
+  <dt><code>geo:<em>latitude</em>,<em>longitude</em>?z=<em>zoom</em></code></dt>
+    <dd>Show the map at the given longitude and latitude at a certain zoom level. A zoom level of
+    1 shows the whole Earth, centered at the given <em>lat</em>,<em>lng</em>. The highest
+    (closest) zoom level is 23.
+      <p>Example: <code>"geo:47.6,-122.3?z=11"</code>
+    </dd>
+  <dt><code>geo:0,0?q=lat,lng(label)</code></dt>
+    <dd>Show the map at the given longitude and latitude with a string label.
+      <p>Example: <code>"geo:0,0?q=34.99,-106.61(Treasure)"</code>
+    </dd>
+  <dt><code>geo:0,0?q=my+street+address</code></dt>
+    <dd>Show the location for "my street address" (may be a specific address or location query).
+      <p>Example: <code>"geo:0,0?q=1600+amphitheatre+parkway+ca"</code>
+    </dd>
+</dl>
+</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>None</dd>
+
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void showMap(Uri geoLocation) {
+    Intent intent = new Intent(Intent.ACTION_VIEW);
+    intent.setData(geoLocation);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.VIEW" />
+        &lt;data android:scheme="geo" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+
+
+
+
+
+
+
+<h2 id="Music">Music or Video</h2>
+
+
+<h3 id="PlayMedia">Play a media file</h3>
+
+<p>To play a music file, use the {@link android.content.Intent#ACTION_VIEW} action and
+specify the URI location of the file in the intent data.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_VIEW}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>
+  <dl>
+    <dt>{@code file:<em>&lt;URI></em>}
+    <dt>{@code content:<em>&lt;URI></em>}
+    <dt>{@code http:<em>&lt;URL></em>}
+  </dl>
+</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>
+  <dl>
+    <dt><code>"audio/*"</code>
+    <dt><code>"application/ogg"</code>
+    <dt><code>"application/x-ogg"</code>
+    <dt><code>"application/itunes"</code>
+    <dt>Or any other that your app may require.
+  </dl>
+</dd>
+
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void playMedia(Uri file) {
+    Intent intent = new Intent(Intent.ACTION_VIEW);
+    intent.setData(file);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.VIEW" />
+        &lt;data android:type="audio/*" />
+        &lt;data android:type="application/ogg" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+
+
+
+
+
+
+
+<h2 id="Phone">Phone</h2>
+
+
+<h3 id="DialPhone">Initiate a phone call</h3>
+
+<p>To open the phone app and dial a phone number, use the {@link
+android.content.Intent#ACTION_DIAL} action and specify a phone number using
+the URI scheme defined below. When the phone app opens, it displays the phone number
+but the user must press the <em>Call</em> button to begin the phone call.</p>
+
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_DIAL}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>{@code tel:&lt;phone-number>}</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>None</dd>
+
+</dl>
+
+
+<p>Valid telephone numbers are those defined
+in <a href="http://tools.ietf.org/html/rfc3966">the IETF RFC 3966</a>.
+Valid examples include the following:</p>
+<ul>
+<li><code>tel:2125551212</code> </li>
+<li><code>tel:(212) 555 1212</code></li>
+</ul>
+<p>The Phone's dialer is good at normalizing schemes, such as
+telephone numbers. So the scheme described isn't strictly required in the
+{@link android.net.Uri#parse(String) Uri.parse()} method.
+However, if you have not tried a scheme or are unsure whether it
+can be handled, use the {@link android.net.Uri#fromParts Uri.fromParts()}
+method instead.</p>
+
+
+<p><b>Example intent:</b></p>
+<pre>
+public void dialPhoneNumber(String phoneNumber) {
+    Intent intent = new Intent(Intent.ACTION_DIAL);
+    intent.setData(Uri.parse("tel:" + phoneNumber));
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+
+
+
+
+
+
+
+
+<h2 id="Settings">Settings</h2>
+
+<h3 id="OpenSettings">Open a specific section of Settings</h3>
+
+<p>To open a screen in the system settings when your app requires the user to change something,
+use one of the following intent actions to open the settings screen respective to the action name.
+</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>
+{@link android.provider.Settings#ACTION_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_WIRELESS_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_AIRPLANE_MODE_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_WIFI_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_APN_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_BLUETOOTH_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_DATE_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_LOCALE_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_INPUT_METHOD_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_DISPLAY_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_SECURITY_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_LOCATION_SOURCE_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_INTERNAL_STORAGE_SETTINGS}<br/>
+{@link android.provider.Settings#ACTION_MEMORY_CARD_SETTINGS}<br/>
+<p>See the {@link android.provider.Settings} documentation for additional settings screens
+that are available.</p>
+</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>None</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>None</dd>
+
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void openWifiSettings() {
+    Intent intent = new Intent(Intent.ACTION_WIFI_SETTINGS);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+
+
+
+
+
+<h2 id="Messaging">Text Messaging</h2>
+
+<h3 id="SendMessage">Compose an SMS/MMS message with attachment</h3>
+
+<p>To initiate an SMS or MMS text message, use one of the intent actions below and specify message
+details such as the phone number, subject, and message body using the extra keys listed below.</p>
+
+<dl>
+<dt><b>Action</b></dt>
+<dd>{@link android.content.Intent#ACTION_SENDTO} or<br>
+    {@link android.content.Intent#ACTION_SEND} or<br>
+    {@link android.content.Intent#ACTION_SEND_MULTIPLE}</dd>
+
+<dt><b>Data URI Scheme</b></dt>
+<dd>
+  <dl>
+    <dt>{@code sms:<em>&lt;phone_number></em>}
+    <dt>{@code smsto:<em>&lt;phone_number></em>}
+    <dt>{@code mms:<em>&lt;phone_number></em>}
+    <dt>{@code mmsto:<em>&lt;phone_number></em>}
+  </dl>
+  <p>Each of these schemes are handled the same.
+</dd>
+
+<dt><b>MIME Type</b></dt>
+<dd>
+  <dl>
+    <dt>{@link org.apache.http.protocol.HTTP#PLAIN_TEXT_TYPE} (<code>"text/plain"</code>)
+    <dt><code>"image/*"</code>
+    <dt><code>"video/*"</code>
+  </dl>
+</dd>
+
+<dt><b>Extras</b> (optional)</dt>
+<dd>
+  <dl>
+    <dt><code>"subject"</code></dt>
+      <dd>A string for the message subject (usually for MMS only).</dd>
+    <dt><code>"sms_body"</code></dt>
+      <dd>A string for the text message.</dd>
+    <dt>{@link android.content.Intent#EXTRA_STREAM}</dt>
+      <dd>A {@link android.net.Uri} pointing to the
+image or video to attach. If using the {@link android.content.Intent#ACTION_SEND_MULTIPLE} action,
+this extra should be an {@link java.util.ArrayList} of {@link
+android.net.Uri}s pointing to the images/videos to attach.</dd>
+  <dl>
+</dd>
+
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void composeMmsMessage(String message, Uri attachment) {
+    Intent intent = new Intent(Intent.ACTION_SEND);
+    intent.setType(HTTP.PLAIN_TEXT_TYPE);
+    intent.putExtra("sms_body", message);
+    intent.putExtra(Intent.EXTRA_STREAM, attachment);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+<p>If you want to ensure that your intent is handled only by a text messaging app (and not other
+email or social apps), then use the {@link android.content.Intent#ACTION_SENDTO} action
+and include the {@code "smsto:"} data scheme. For example:</p>
+
+<pre>
+public void composeMmsMessage(String message, Uri attachment) {
+    Intent intent = new Intent(Intent.ACTION_SEND);
+    intent.setData(Uri.parse("smsto:"));  // This ensures only SMS apps respond
+    intent.putExtra("sms_body", message);
+    intent.putExtra(Intent.EXTRA_STREAM, attachment);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.SEND" />
+        &lt;data android:type="text/plain" />
+        &lt;data android:type="image/*" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+<p class="note"><strong>Note:</strong> If you're developing an SMS/MMS messaging app, you must
+implement intent filters for several additional actions in order to be available as the
+<em>default SMS app</em> on Android 4.4 and higher. For more information, see the documentation
+at {@link android.provider.Telephony}.</p>
+
+
+
+
+
+
+
+
+
+
+<h2 id="Browser">Web Browser</h2>
+
+<h3 id="ViewUrl">Load a web URL</h3>
+
+<p>To open a web page, use the {@link android.content.Intent#ACTION_VIEW} action
+and specify the web URL in the intent data.</p>
+
+<dl>
+  <dt><b>Action</b></dt>
+  <dd>{@link android.content.Intent#ACTION_VIEW}<dd>
+
+  <dt><b>Data URI Scheme</b></dt>
+  <dd>{@code http:<em>&lt;URL></em>}<br/>
+    {@code https:<em>&lt;URL></em>}</dd>
+
+  <dt><b>MIME Type</b></dt>
+  <dd>
+    <dl>
+      <dt>{@link org.apache.http.protocol.HTTP#PLAIN_TEXT_TYPE} (<code>"text/plain"</code>)
+      <dt><code>"text/html"</code>
+      <dt><code>"application/xhtml+xml"</code>
+      <dt><code>"application/vnd.wap.xhtml+xml"</code>
+    </dl>
+  </dd>
+</dl>
+
+
+<p><b>Example intent:</b></p>
+<pre>
+public void openWebPage(String url) {
+    Uri webpage = Uri.parse(url);
+    Intent intent = new Intent(Intent.ACTION_VIEW, webpage);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+<p><b>Example intent filter:</b></p>
+<pre>
+&lt;activity ...>
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.VIEW" />
+        &lt;!-- Include the host attribute if you want your app to respond
+             only to URLs with your app's domain. -->
+        &lt;data android:scheme="http" android:host="www.example.com" />
+        &lt;category android:name="android.intent.category.DEFAULT" />
+        &lt;!-- The BROWSABLE category is required to get links from web pages. -->
+        &lt;category android:name="android.intent.category.BROWSABLE" />
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+
+<p class="note"><strong>Tip:</strong> If your Android app provides functionality similar to
+your web site, include an intent filter for URLs that point to your web site. Then,
+if users have your app installed, links from emails or other web pages pointing to your web site
+open your Android app instead of your web page.</p>
+
+
+
+
+<h3 id="SearchWeb">Perform a web search</h3>
+
+<p>To initiate a web search, use the {@link android.content.Intent#ACTION_WEB_SEARCH} action
+and specify the search string in the
+{@link android.app.SearchManager#QUERY SearchManager.QUERY} extra.</p>
+
+
+<dl>
+  <dt><b>Action</b></dt>
+  <dd>{@link android.content.Intent#ACTION_WEB_SEARCH}</dd>
+
+  <dt><b>Data URI Scheme</b></dt>
+  <dd>None</dd>
+
+  <dt><b>MIME Type</b></dt>
+  <dd>None</dd>
+
+  <dt><b>Extras</b></dt>
+  <dd>
+    <dl>
+      <dt>{@link android.app.SearchManager#QUERY SearchManager.QUERY}</dt>
+      <dd>The search string.</dd>
+    </dl>
+  </dd>
+</dl>
+
+<p><b>Example intent:</b></p>
+<pre>
+public void searchWeb(String query) {
+    Intent intent = new Intent(Intent.ACTION_SEARCH);
+    intent.putExtra(SearchManager.QUERY, query);
+    if (intent.resolveActivity(getPackageManager()) != null) {
+        startActivity(intent);
+    }
+}
+</pre>
+
+
+
diff --git a/docs/html/guide/components/intents-filters.jd b/docs/html/guide/components/intents-filters.jd
index dfe5fac..2f8c407 100644
--- a/docs/html/guide/components/intents-filters.jd
+++ b/docs/html/guide/components/intents-filters.jd
@@ -1,4 +1,5 @@
 page.title=Intents and Intent Filters
+page.tags="IntentFilter"
 @jd:body
 
 <div id="qv-wrapper">
@@ -6,1050 +7,907 @@
 
 <h2>In this document</h2>
 <ol>
-<li><a href="#iobjs">Intent Objects</a></li>
-<li><a href="#ires">Intent Resolution</a></li>
-<li style="margin-left: 2em"><a href="#ifs">Intent filters</a></li>
-<li style="margin-left: 2em"><a href="#ccases">Common cases</a></li>
-<li style="margin-left: 2em"><a href="#imatch">Using intent matching</a></li>
-<li><a href="#npex">Note Pad Example</a></li>
+  <li><a href="#Types">Intent Types</a></li>
+  <li><a href="#Building">Building an Intent</a>
+    <ol>
+      <li><a href="#ExampleExplicit">Example explicit intent</a></li>
+      <li><a href="#ExampleSend">Example implicit intent</a></li>
+      <li><a href="#ForceChooser">Forcing an app chooser</a></li>
+    </ol>
+  </li>
+  <li><a href="#Receiving">Receiving an Implicit Intent</a>
+    <ol>
+      <li><a href="#ExampleFilters">Example filters</a></li>
+    </ol>
+  </li>
+  <li><a href="#PendingIntent">Using a Pending Intent</a></li>
+  <li><a href="#Resolution">Intent Resolution</a>
+    <ol>
+      <li><a href="#ActionTest">Action test</a></li>
+      <li><a href="#CategoryTest">Category test</a></li>
+      <li><a href="#DataTest">Data test</a></li>
+      <li><a href="#imatch">Intent matching</a></li>
+    </ol>
+  </li>
 </ol>
 
-<h2>Key classes</h2>
+<h2>See also</h2>
 <ol>
-<li>{@link android.content.Intent}</li>
-<li>{@link android.content.IntentFilter}</li>
-<li>{@link android.content.BroadcastReceiver}</li>
-<li>{@link android.content.pm.PackageManager}</li>
+<li><a href="{@docRoot}training/basics/intents/index.html">Interacting with Other Apps</a></li>
+<li><a href="{@docRoot}training/sharing/index.html">Sharing Content</a></li>
 </ol>
 
 </div>
 </div>
 
 
-<p>
-Three of the core components of an application &mdash; activities, services, and 
-broadcast receivers &mdash; are activated through messages, called <i>intents</i>.   
-Intent messaging is a facility for late run-time binding between components in the same 
-or different applications.  The intent itself, an {@link android.content.Intent} 
-object, is a passive data structure holding an abstract description of an operation 
-to be performed &mdash; or, often in the case of broadcasts, a description of something 
-that has happened and is being announced.  There are separate mechanisms for 
-delivering intents to each type of component: 
-</p>
+
+
+<p>An {@link android.content.Intent} is a messaging object you can use to request an action
+from another <a href="{@docRoot}guide/components/fundamentals.html#Components">app component</a>.
+Although intents facilitate communication between components in several ways, there are three
+fundamental use-cases:</p>
 
 <ul>
-<li>An Intent object is passed to <code>{@link android.content.Context#startActivity 
-Context.startActivity()}</code> or <code>{@link android.app.Activity#startActivityForResult 
-Activity.startActivityForResult()}</code> to launch an activity or get an existing 
-activity to do something new. (It can also be passed to 
-<code>{@link android.app.Activity#setResult(int, Intent) Activity.setResult()}</code>
-to return information to the activity that called {@code startActivityForResult()}.)</li>
+<li><b>To start an activity:</b>
+<p>An {@link android.app.Activity} represents a single screen in an app. You can start a new
+instance of an {@link android.app.Activity} by passing an {@link android.content.Intent}
+to {@link android.content.Context#startActivity startActivity()}. The {@link android.content.Intent}
+describes the activity to start and carries any necessary data.</p>
 
-<li><p>An Intent object is passed to <code>{@link android.content.Context#startService 
-Context.startService()}</code> to initiate a service or deliver new instructions to an 
-ongoing service.  Similarly, an intent can be passed to <code>{@link 
-android.content.Context#bindService Context.bindService()}</code> to establish a 
-connection between the calling component and a target service.  It can optionally
-initiate the service if it's not already running.</p></li>
+<p>If you want to receive a result from the activity when it finishes,
+call {@link android.app.Activity#startActivityForResult
+startActivityForResult()}. Your activity receives the result
+as a separate {@link android.content.Intent} object in your activity's {@link
+android.app.Activity#onActivityResult onActivityResult()} callback.
+For more information, see the <a
+href="{@docRoot}guide/components/activities.html">Activities</a> guide.</p></li>
 
-<li><p>Intent objects passed to any of the broadcast methods (such as <code>{@link 
-android.content.Context#sendBroadcast(Intent) Context.sendBroadcast()}</code>, 
-<code>{@link android.content.Context#sendOrderedBroadcast(Intent, String) 
-Context.sendOrderedBroadcast()}</code>, or <code>{@link 
-android.content.Context#sendStickyBroadcast Context.sendStickyBroadcast()}</code>) 
-are delivered to all interested broadcast receivers.  Many kinds of broadcasts 
-originate in system code.</p></li>
+<li><b>To start a service:</b>
+<p>A {@link android.app.Service} is a component that performs operations in the background
+without a user interface. You can start a service to perform a one-time operation
+(such as download a file) by passing an {@link android.content.Intent}
+to {@link android.content.Context#startService startService()}. The {@link android.content.Intent}
+describes the service to start and carries any necessary data.</p>
+
+<p>If the service is designed with a client-server interface, you can bind to the service
+from another component by passing an {@link android.content.Intent} to {@link
+android.content.Context#bindService bindService()}</code>. For more information, see the <a
+href="{@docRoot}guide/components/services.html">Services</a> guide.</p></li>
+
+<li><b>To deliver a broadcast:</b>
+<p>A broadcast is a message that any app can receive. The system delivers various
+broadcasts for system events, such as when the system boots up or the device starts charging.
+You can deliver a broadcast to other apps by passing an {@link android.content.Intent}
+to {@link android.content.Context#sendBroadcast(Intent) sendBroadcast()},
+{@link android.content.Context#sendOrderedBroadcast(Intent, String)
+sendOrderedBroadcast()}, or {@link
+android.content.Context#sendStickyBroadcast sendStickyBroadcast()}.</p>
+</li>
 </ul>
 
-<p>
-In each case, the Android system finds the appropriate activity, service, or set 
-of broadcast receivers to respond to the intent, instantiating them if necessary. 
-There is no overlap within these messaging systems:  Broadcast intents are delivered 
-only to broadcast receivers, never to activities or services.  An intent passed to 
-{@code startActivity()} is delivered only to an activity, never to a service or 
-broadcast receiver, and so on.
+
+
+
+<h2 id="Types">Intent Types</h2>
+
+<p>There are two types of intents:</p>
+
+<ul>
+<li><b>Explicit intents</b> specify the component to start by name (the
+fully-qualified class name). You'll typically use an explicit intent to start a component in
+your own app, because you know the class name of the activity or service you want to start. For
+example, start a new activity in response to a user action or start a service to download
+a file in the background.</li>
+
+<li><b>Implicit intents</b> do not name a specific component, but instead declare a general action
+to perform, which allows a component from another app to handle it. For example, if you want to
+show the user a location on a map, you can use an implicit intent to request that another capable
+app show a specified location on a map.</li>
+</ul>
+
+<p>When you create an explicit intent to start an activity or service, the system immediately
+starts the app component specified in the {@link android.content.Intent} object.</p>
+
+<div class="figure" style="width:446px">
+<img src="{@docRoot}images/components/intent-filters@2x.png" width="446" alt=""/>
+<p class="img-caption"><strong>Figure 1.</strong> Illustration of how an implicit intent is
+delivered through the system to start another activity: <b>[1]</b> <em>Activity A</em> creates an
+{@link android.content.Intent} with an action description and passes it to {@link
+android.content.Context#startActivity startActivity()}. <b>[2]</b> The Android System searches all
+apps for an intent filter that matches the intent. When a match is found, <b>[3]</b> the system
+starts the matching activity (<em>Activity B</em>) by invoking its {@link
+android.app.Activity#onCreate onCreate()} method and passing it the {@link android.content.Intent}.
 </p>
+</div>
 
-<p>
-This document begins with a description of Intent objects.  It then describes the 
-rules Android uses to map intents to components &mdash; how it resolves which 
-component should receive an intent message.  For intents that don't explicitly 
-name a target component, this process involves testing the Intent object against 
-<i>intent filters</i> associated with potential targets. 
-</p>
+<p>When you create an implicit intent, the Android system finds the appropriate component to start
+by comparing the contents of the intent to the <em>intent filters</em> declared in the <a href=
+"{@docRoot}guide/topics/manifest/manifest-intro.html">manifest file</a> of other apps on the
+device. If the intent matches an intent filter, the system starts that component and delivers it
+the {@link android.content.Intent} object. If multiple intent filters are compatible, the system
+displays a dialog so the user can pick which app to use.</p>
+
+<p>An intent filter is an expression in an app's manifest file that
+specifies the type of intents that the component
+would like to receive. For instance, by declaring an intent filter for an activity,
+you make it possible for other apps to directly start your activity with a certain kind of intent.
+Likewise, if you do <em>not</em> declare any intent filters for an activity, then it can be started
+only with an explicit intent.</p>
+
+<p class="caution"><strong>Caution:</strong> To ensure your app is secure, always use an explicit
+intent when starting a {@link android.app.Service} and do not
+declare intent filters for your services. Using an implicit intent to start a service is a
+security hazard because you cannot be certain what service will respond to the intent,
+and the user cannot see which service starts.</p>
 
 
-<h2><a name="iobjs"></a>Intent Objects</h2>
 
-<p>
-An {@link android.content.Intent} object is a bundle of information.  It 
-contains information of interest to the component that receives the intent 
-(such as the action to be taken and the data to act on) plus information 
-of interest to the Android system (such as the category of component that 
-should handle the intent and instructions on how to launch a target activity).  
-Principally, it can contain the following:
-</p>
+
+
+<h2 id="Building">Building an Intent</h2>
+
+<p>An {@link android.content.Intent} object carries information that the Android system uses
+to determine which component to start (such as the exact component name or component
+category that should receive the intent), plus information that the recipient component uses in
+order to properly perform the action (such as the action to take and the data to act upon).</p>
+
+
+<p>The primary information contained in an {@link android.content.Intent} is the following:</p>
 
 <dl>
 
-<dt><b>Component name</b><a name="cname"></a></dt> 
-<dd>The name of the component that should handle the intent.  This field is 
-a {@link android.content.ComponentName} object &mdash; a combination of the 
-fully qualified class name of the target component (for example "{@code 
-com.example.project.app.FreneticActivity}") and the package name set
-in the manifest file of the application where the component resides (for 
-example, "{@code com.example.project}").  The package part of the component 
-name and the package name set in the manifest do not necessarily have to match.
+<dt><b>Component name</b></dt>
+<dd>The name of the component to start.
 
-<p>  
-The component name is optional.  If it is set, the Intent object is 
-delivered to an instance of the designated class.  If it is not set, 
-Android uses other information in the Intent object to locate a suitable 
-target &mdash; see <a href="#ires">Intent Resolution</a>, later in this 
-document.
-</p>
+<p>This is optional, but it's the critical piece of information that makes an intent
+<b>explicit</b>, meaning that the intent should be delivered only to the app component
+defined by the component name. Without a component name, the intent is <b>implicit</b> and the
+system decides which component should receive the intent based on the other intent information
+(such as the action, data, and category&mdash;described below). So if you need to start a specific
+component in your app, you should specify the component name.</p>
 
-<p>
-The component name is set by <code>{@link android.content.Intent#setComponent 
-setComponent()}</code>,  <code>{@link android.content.Intent#setClass 
-setClass()}</code>, or <code>{@link android.content.Intent#setClassName(String, String) 
-setClassName()}</code> and read by <code>{@link android.content.Intent#getComponent 
-getComponent()}</code>. 
-</p>
+<p class="note"><strong>Note:</strong> When starting a {@link android.app.Service}, you should
+<strong>always specify the component name</strong>. Otherwise, you cannot be certain what service
+will respond to the intent, and the user cannot see which service starts.</p>
+
+<p>This field of the {@link android.content.Intent} is a
+{@link android.content.ComponentName} object, which you can specify using a fully
+qualified class name of the target component, including the package name of the app. For example,
+{@code com.example.ExampleActivity}. You can set the component name with {@link
+android.content.Intent#setComponent setComponent()}, {@link android.content.Intent#setClass
+setClass()}, {@link android.content.Intent#setClassName(String, String) setClassName()}, or with the
+{@link android.content.Intent} constructor.</p>
+
 </dd>
 
 <p><dt><b>Action</b></dt>
-<dd>A string naming the action to be performed &mdash; or, in the case of broadcast 
-intents, the action that took place and is being reported.  The Intent class defines 
-a number of action constants, including these:
-</p>
+<dd>A string that specifies the generic action to perform (such as <em>view</em> or <em>pick</em>).
 
-<table>
-<tr>
-   <th>Constant</th>
-   <th>Target component</th>
-   <th>Action</th>
-</tr><tr>
-   <td>{@code ACTION_CALL}
-   <td>activity
-   <td>Initiate a phone call.
-</tr><tr>
-   <td>{@code ACTION_EDIT}
-   <td>activity
-   <td>Display data for the user to edit.
-</tr><tr>
-   <td>{@code ACTION_MAIN}
-   <td>activity
-   <td>Start up as the initial activity of a task, with no data input and no returned output.
-</tr><tr>
-   <td>{@code ACTION_SYNC}
-   <td>activity
-   <td>Synchronize data on a server with data on the mobile device.
-</tr><tr>
-   <td>{@code ACTION_BATTERY_LOW}
-   <td>broadcast receiver
-   <td>A warning that the battery is low.
-</tr><tr>
-   <td>{@code ACTION_HEADSET_PLUG}
-   <td>broadcast receiver
-   <td>A headset has been plugged into the device, or unplugged from it.
-</tr><tr>
-   <td>{@code ACTION_SCREEN_ON}
-   <td>broadcast receiver
-   <td>The screen has been turned on.
-</tr><tr>
-   <td>{@code ACTION_TIMEZONE_CHANGED}
-   <td>broadcast receiver
-   <td>The setting for the time zone has changed.
-</tr>
-</table>
+<p>In the case of a broadcast intent, this is the action that took place and is being reported.
+The action largely determines how the rest of the intent is structured&mdash;particularly
+what is contained in the data and extras.
 
-<p>
-See the {@link android.content.Intent} class description for a list of 
-pre-defined constants for generic actions.  Other actions are defined 
-elsewhere in the Android API.
-You can also define your own action strings for activating the components 
-in your application.  Those you invent should include the application 
-package as a prefix &mdash; for example: 
-"<code>com.example.project.SHOW_COLOR</code>". 
-</p>
+<p>You can specify your own actions for use by intents within your app (or for use by other
+apps to invoke components in your app), but you should usually use action constants
+defined by the {@link android.content.Intent} class or other framework classes. Here are some
+common actions for starting an activity:</p>
 
-<p>
-The action largely determines how the rest of the intent is structured
-&mdash; particularly the <a href="#data">data</a> and 
-<a href="#extras">extras</a> fields &mdash; 
-much as a method name determines a set of arguments and a return value.
-For this reason, it's a good idea to use action names that are
-as specific as possible, and to couple them tightly to the other fields of
-the intent.  In other words, instead of defining an action in isolation,
-define an entire protocol for the Intent objects your components can handle.
-</p>
+<dl>
+<dt>{@link android.content.Intent#ACTION_VIEW}</dt>
+   <dd>Use this action in an intent with {@link
+   android.content.Context#startActivity startActivity()} when you have some information that
+   an activity can show to the user, such as a photo to view in a gallery app, or an address to
+   view in a map app.</dd>
 
-<p>
-The action in an Intent object is set by the 
-<code>{@link android.content.Intent#setAction setAction()}</code> 
-method and read by 
-<code>{@link android.content.Intent#getAction getAction()}</code>.
-</p>
+<dt>{@link android.content.Intent#ACTION_SEND}</dt>
+   <dd>Also known as the "share" intent, you should use this in an intent with {@link
+   android.content.Context#startActivity startActivity()} when you have some data that the user can
+   share through another app, such as an email app or social sharing app.</dd>
+</dl>
+
+<p>See the {@link android.content.Intent} class reference for more
+constants that define generic actions.  Other actions are defined
+elsewhere in the Android framework, such as in {@link android.provider.Settings} for actions
+that open specific screens in the system's Settings app.</p>
+
+<p>You can specify the action for an intent with {@link android.content.Intent#setAction
+setAction()} or with an {@link android.content.Intent} constructor.</p>
+
+<p>If you define your own actions, be sure to include your app's package name
+as a prefix. For example:</p>
+<pre>static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";</pre>
 </dd>
 
-<p><dt><b>Data</b><a name="data"></a></dt>
-<dd>The URI of the data to be acted on and the MIME type of that data.  Different 
-actions are paired with different kinds of data specifications.  For example, if 
-the action field is {@code ACTION_EDIT}, 
-the data field would contain the URI of the document to be displayed for editing.  
-If the action is {@code ACTION_CALL}, the data field would be a {@code tel:} URI 
-with the number to call.  Similarly, if the action is {@code ACTION_VIEW} and the 
-data field is an {@code http:} URI, the receiving activity would be called upon 
-to download and display whatever data the URI refers to.
+<dt><b>Data</b></dt>
+<dd>The URI (a {@link android.net.Uri} object) that references the data to be acted on and/or the
+MIME type of that data. The type of data supplied is generally dictated by the intent's action. For
+example, if the action is {@link android.content.Intent#ACTION_EDIT}, the data should contain the
+URI of the document to edit.
 
-<p>
-When matching an intent to a component that is capable of handling the data, 
-it's often important to know the type of data (its MIME type) in addition to its URI.  
-For example, a component able to display image data should not be called
-upon to play an audio file.
-</p>
+<p>When creating an intent,
+it's often important to specify the type of data (its MIME type) in addition to its URI.
+For example, an activity that's able to display images probably won't be able
+to play an audio file, even though the URI formats could be similar.
+So specifying the MIME type of your data helps the Android
+system find the best component to receive your intent.
+However, the MIME type can sometimes be inferred from the URI&mdash;particularly when the data is a
+{@code content:} URI, which indicates the data is located on the device and controlled by a
+{@link android.content.ContentProvider}, which makes the data MIME type visible to the system.</p>
 
-<p>
-In many cases, the data type can be inferred from the URI &mdash; particularly 
-{@code content:} URIs, which indicate that the data is located on the device and
-controlled by a content provider (see the  
-<a href="{@docRoot}guide/topics/providers/content-providers.html">separate 
-discussion on content providers</a>).  But the type can also be explicitly set 
-in the Intent object.  
-The <code>{@link android.content.Intent#setData setData()}</code> method specifies 
-data only as a URI, <code>{@link android.content.Intent#setType setType()}</code> 
-specifies it only as a MIME type, and <code>{@link 
-android.content.Intent#setDataAndType setDataAndType()}</code> specifies it as both 
-a URI and a MIME type.  The URI is read by <code>{@link 
-android.content.Intent#getData getData()}</code> and the type by <code>{@link 
-android.content.Intent#getType getType()}</code>.
-</p>
+<p>To set only the data URI, call {@link android.content.Intent#setData setData()}.
+To set only the MIME type, call {@link android.content.Intent#setType setType()}. If necessary, you
+can set both explicitly with {@link
+android.content.Intent#setDataAndType setDataAndType()}.</p>
+
+<p class="caution"><strong>Caution:</strong> If you want to set both the URI and MIME type,
+<strong>do not</strong> call {@link android.content.Intent#setData setData()} and
+{@link android.content.Intent#setType setType()} because they each nullify the value of the other.
+Always use {@link android.content.Intent#setDataAndType setDataAndType()} to set both
+URI and MIME type.</p>
 </dd>
 
 <p><dt><b>Category</b></dt>
-<dd>A string containing additional information about the kind of component 
-that should handle the intent.  Any number of category descriptions can be 
-placed in an Intent object.  As it does for actions, the Intent class defines
-several category constants, including these: 
+<dd>A string containing additional information about the kind of component
+that should handle the intent.  Any number of category descriptions can be
+placed in an intent, but most intents do not require a category.
+Here are some common categories:
 
-<table>
-<tr>
-   <th>Constant</th>
-   <th>Meaning</th>
-</tr><tr>
-   <td>{@code CATEGORY_BROWSABLE}
-   <td>The target activity can be safely invoked by the browser to display data 
-       referenced by a link &mdash; for example, an image or an e-mail message.
-</tr><tr>
-   <td>{@code CATEGORY_GADGET}
-   <td>The activity can be embedded inside of another activity that hosts gadgets.
-</tr><tr>
-   <td>{@code CATEGORY_HOME}
-   <td>The activity displays the home screen, the first screen the user sees when 
-       the device is turned on or when the <em>Home</em> button is pressed.
-</tr><tr>
-   <td>{@code CATEGORY_LAUNCHER}
-   <td>The activity can be the initial activity of a task and is listed in 
-       the top-level application launcher.
-</tr><tr>
-   <td>{@code CATEGORY_PREFERENCE}
-   <td>The target activity is a preference panel.
-</tr>
-</table> 
+<dl>
+<dt>{@link android.content.Intent#CATEGORY_BROWSABLE}</dt>
+  <dd>The target activity allows itself to be started by a web browser to display data
+       referenced by a link&mdash;such as an image or an e-mail message.
+  </dd>
+<dt>{@link android.content.Intent#CATEGORY_LAUNCHER}</dt>
+  <dd>The activity is the initial activity of a task and is listed in
+       the system's application launcher.
+  </dd>
+</dl>
 
-<p>
-See the {@link android.content.Intent} class description for the full list of 
-categories.
-</p>
+<p>See the {@link android.content.Intent} class description for the full list of
+categories.</p>
 
-<p>
-The <code>{@link android.content.Intent#addCategory addCategory()}</code> method 
-places a category in an Intent object, <code>{@link android.content.Intent#removeCategory 
-removeCategory()}</code> deletes a category previously added, and <code>{@link android.content.Intent#getCategories getCategories()}</code> gets the set of all 
-categories currently in the object. 
-</p>
+<p>You can specify a category with {@link android.content.Intent#addCategory addCategory()}.</p>
+</dd>
+</dl>
+
+
+<p>These properties listed above (component name, action, data, and category) represent the
+defining characteristics of an intent. By reading these properties, the Android system
+is able to resolve which app component it should start.</p>
+
+<p>However, an intent can carry additional information that does not affect
+how it is resolved to an app component. An intent can also supply:</p>
+
+<dl>
+<dt><b>Extras</b></dt>
+<dd>Key-value pairs that carry additional information required to accomplish the requested action.
+Just as some actions use particular kinds of data URIs, some actions also use particular extras.
+
+<p>You can add extra data with various {@link android.content.Intent#putExtra putExtra()} methods,
+each accepting two parameters: the key name and the value.
+You can also create a {@link android.os.Bundle} object with all the extra data, then insert
+the {@link android.os.Bundle} in the {@link android.content.Intent} with {@link
+android.content.Intent#putExtras putExtras()}.</p>
+
+<p>For example, when creating an intent to send an email with
+{@link android.content.Intent#ACTION_SEND}, you can specify the "to" recipient with the
+{@link android.content.Intent#EXTRA_EMAIL} key, and specify the "subject" with the
+{@link android.content.Intent#EXTRA_SUBJECT} key.</p>
+
+<p>The {@link android.content.Intent} class specifies many {@code EXTRA_*} constants
+for standardized data types. If you need to declare your own extra keys (for intents that
+your app receives), be sure to include your app's package name
+as a prefix. For example:</p>
+<pre>static final String EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS";</pre>
 </dd>
 
-<p><dt><b>Extras</b><a name="extras"></a></dt>
-<dd>Key-value pairs for additional information that should be delivered to the 
-component handling the intent.  Just as some actions are paired with particular 
-kinds of data URIs, some are paired with particular extras.  For example, an 
-{@code ACTION_TIMEZONE_CHANGED} intent has a "{@code time-zone}" extra that 
-identifies the new time zone, and {@code ACTION_HEADSET_PLUG} has a 
-"{@code state}" extra indicating whether the headset is now plugged in or 
-unplugged, as well as a "{@code name}" extra for the type of headset. 
-If you were to invent a {@code SHOW_COLOR} action, the color value would
-be set in an extra key-value pair.
+<dt><b>Flags</b></dt>
+<dd>Flags defined in the {@link android.content.Intent} class that function as metadata for the
+intent. The flags may instruct the Android system how to launch an activity (for example, which
+<a href="{@docRoot}guide/components/tasks-and-back-stack.html">task</a> the activity should belong
+to) and how to treat it after it's launched (for example, whether it belongs in the list of recent
+activities).
 
-<p>
-The Intent object has a series of {@code put...()} methods for inserting various 
-types of extra data and a similar  set of {@code get...()} methods for reading 
-the data.  These methods parallel those for {@link android.os.Bundle} objects.  
-In fact, the extras can be installed and read as a Bundle using the <code>{@link 
-android.content.Intent#putExtras putExtras()}</code> and <code>{@link 
-android.content.Intent#getExtras getExtras()}</code> methods.
-</p>
-</dd>
-
-<p><dt><b>Flags</b></dt>
-<dd>Flags of various sorts.  Many instruct the Android system how to launch an 
-activity (for example, which task the activity should belong to) and how to treat 
-it after it's launched (for example, whether it belongs in the list of recent 
-activities).  All these flags are defined in the Intent class.   
+<p>For more information, see the {@link android.content.Intent#setFlags setFlags()} method.</p>
 </dd>
 
 </dl>
 
-<p>
-The Android system and the applications that come with the platform employ 
-Intent objects both to send out system-originated broadcasts and to activate 
-system-defined components.  To see how to structure an intent to activate a 
-system component, consult the 
-<a href="{@docRoot}guide/appendix/g-app-intents.html">list of intents</a> 
-in the reference.  
-</p>
 
 
-<h2><a name="ires"></a>Intent Resolution</h2>
 
-<p>
-Intents can be divided into two groups:
-</p>
+<h3 id="ExampleExplicit">Example explicit intent</h3>
 
-<ul>
-<li><i>Explicit intents</i> designate the target component by its 
-name (the <a href="#cname">component name field</a>, mentioned earlier, 
-has a value set).  Since component names would generally not be known to 
-developers of other applications, explicit intents are typically used 
-for application-internal messages &mdash; such as an activity starting 
-a subordinate service or launching a sister activity.</li>
+<p>An explicit intent is one that you use to launch a specific app component, such as
+a particular activity or service in your app. To create an explicit intent, define
+the component name for the {@link android.content.Intent} object&mdash;all
+other intent properties are optional.</p>
 
-<li><p><i>Implicit intents</i> do not name a target (the field for 
-the component name is blank).  Implicit intents are often used to 
-activate components in other applications.</p></li>   
-</ul>
+<p>For example, if you built a service in your app, named {@code DownloadService},
+designed to download a file from the web, you can start it with the following code:</p>
 
-<p>
-Android delivers an explicit intent to an instance of the designated 
-target class.  Nothing in the Intent object other than the component 
-name matters for determining which component should get the intent.  
-</p>
+<pre>
+// Executed in an Activity, so 'this' is the {@link android.content.Context}
+// The fileUrl is a string URL, such as "http://www.example.com/image.png"
+Intent downloadIntent = new Intent(this, DownloadService.class);
+downloadIntent.setData({@link android.net.Uri#parse Uri.parse}(fileUrl));
+startService(downloadIntent);
+</pre>
 
-<p>
-A different strategy is needed for implicit intents.  In the absence of a 
-designated target, the Android system must find the best component (or 
-components) to handle the intent &mdash; a single activity or service to 
-perform the requested action or the set of broadcast receivers to respond 
-to the broadcast announcement.  It does so by comparing the contents of 
-the Intent object to <i>intent filters</i>, structures associated with 
-components that can potentially receive intents.  Filters advertise the 
-capabilities of a component and delimit the intents it can handle.  They 
-open the component to the possibility of receiving implicit intents of 
-the advertised type.  If a component does not have any intent filters, 
-it can receive only explicit intents.  A component with filters can 
-receive both explicit and implicit intents.
-</p>
+<p>The {@link android.content.Intent#Intent(Context,Class)}
+constructor supplies the app {@link android.content.Context} and the
+component a {@link java.lang.Class} object. As such,
+this intent explicitly starts the {@code DownloadService} class in the app.</p>
 
-<p>
-Only three aspects of an Intent object are consulted when the object
-is tested against an intent filter:
-</p>
-
-<p style="margin-left: 2em">action
-<br/>data (both URI and data type)
-<br/>category</p>
-
-<p>
-The extras and flags play no part in resolving which component receives
-an intent.
-</p>
+<p>For more information about building and starting a service, see the
+<a href="{@docRoot}guide/components/services.html">Services</a> guide.</p>
 
 
-<h3><a name="ifs"></a>Intent filters</h3>
 
-<p>
-To inform the system which implicit intents they can handle, activities, 
-services, and broadcast receivers can have one or more intent filters.  
-Each filter describes a capability of the component, a set of intents that 
-the component is willing to receive.  It, in effect, filters in 
-intents of a desired type, while filtering out unwanted 
-intents &mdash; but only unwanted implicit intents (those that don't name
-a target class).  An explicit intent is always delivered to its target, 
-no matter what it contains; the filter is not consulted.  But an implicit 
-intent is delivered to a component only if it can pass through one of the 
-component's filters.
-</p>
 
-<p>
-A component has separate filters for each job it can do, each face it can 
-present to the user.  For example, the NoteEditor activity of the sample
-Note Pad application has two filters &mdash; one for starting up with a
-specific note that the user can view or edit, and another for starting 
-with a new, blank note that the user can fill in and save.  (All of Note 
-Pad's filters are described in the <a href="#npex">Note Pad Example</a>
-section, later.)
-</p>
+<h3 id="ExampleSend">Example implicit intent</h3>
+
+<p>An implicit intent specifies an action that can invoke any app on the device able
+to perform the action. Using an implicit intent is useful when your app cannot perform the
+action, but other apps probably can and you'd like the user to pick which app to use.</p>
+
+<p>For example, if you have content you want the user to share with other people, create an intent
+with the {@link android.content.Intent#ACTION_SEND} action
+and add extras that specify the content to share. When you call
+{@link android.content.Context#startActivity startActivity()} with that intent, the user can
+pick an app through which to share the content.</p>
+
+<p class="caution"><strong>Caution:</strong> It's possible that a user won't have <em>any</em>
+apps that handle the implicit intent you send to {@link android.content.Context#startActivity
+startActivity()}. If that happens, the call will fail and your app will crash. To verify
+that an activity will receive the intent, call {@link android.content.Intent#resolveActivity
+resolveActivity()} on your {@link android.content.Intent} object. If the result is non-null,
+then there is at least one app that can handle the intent and it's safe to call
+{@link android.content.Context#startActivity startActivity()}. If the result is null,
+you should not use the intent and, if possible, you should disable the feature that issues
+the intent.</p>
+
+
+<pre>
+// Create the text message with a string
+Intent sendIntent = new Intent();
+sendIntent.setAction(Intent.ACTION_SEND);
+sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
+sendIntent.setType({@link
+        org.apache.http.protocol.HTTP#PLAIN_TEXT_TYPE
+        HTTP.PLAIN_TEXT_TYPE}); // "text/plain" MIME type
+
+// Verify that the intent will resolve to an activity
+if (sendIntent.resolveActivity(getPackageManager()) != null) {
+    startActivity(sendIntent);
+}
+</pre>
+
+<p class="note"><strong>Note:</strong> In this case, a URI is not used, but the intent's data type
+is declared to specify the content carried by the extras.</p>
+
+
+<p>When {@link android.content.Context#startActivity startActivity()} is called, the system
+examines all of the installed apps to determine which ones can handle this kind of intent (an
+intent with the {@link android.content.Intent#ACTION_SEND} action and that carries "text/plain"
+data). If there's only one app that can handle it, that app opens immediately and is given the
+intent. If multiple activities accept the intent, the system
+displays a dialog so the user can pick which app to use..</p>
+
+
+<div class="figure" style="width:200px">
+  <img src="{@docRoot}images/training/basics/intent-chooser.png" alt="">
+  <p class="img-caption"><strong>Figure 2.</strong> A chooser dialog.</p>
+</div>
+
+<h3 id="ForceChooser">Forcing an app chooser</h3>
+
+<p>When there is more than one app that responds to your implicit intent,
+the user can select which app to use and make that app the default choice for the
+action. This is nice when performing an action for which the user
+probably wants to use the same app from now on, such as when opening a web page (users
+often prefer just one web browser) .</p>
+
+<p>However, if multiple apps can respond to the intent and the user might want to use a different
+app each time, you should explicitly show a chooser dialog. The chooser dialog asks the
+user to select which app to use for the action every time (the user cannot select a default app for
+the action). For example, when your app performs "share" with the {@link
+android.content.Intent#ACTION_SEND} action, users may want to share using a different app depending
+on their current situation, so you should always use the chooser dialog, as shown in figure 2.</p>
+
+
+
+
+<p>To show the chooser, create an {@link android.content.Intent} using {@link
+android.content.Intent#createChooser createChooser()} and pass it to {@link
+android.app.Activity#startActivity startActivity()}. For example:</p>
+
+<pre>
+Intent intent = new Intent(Intent.ACTION_SEND);
+...
+
+// Always use string resources for UI text.
+// This says something like "Share this photo with"
+String title = getResources().getString(R.string.chooser_title);
+// Create intent to show chooser
+Intent chooser = Intent.createChooser(intent, title);
+
+// Verify the intent will resolve to at least one activity
+if (sendIntent.resolveActivity(getPackageManager()) != null) {
+    startActivity(sendIntent);
+}
+</pre>
+
+<p>This displays a dialog with a list of apps that respond to the intent passed to the {@link
+android.content.Intent#createChooser createChooser()} method and uses the supplied text as the
+dialog title.</p>
+
+
+
+
+
+
+
+
+
+<h2 id="Receiving">Receiving an Implicit Intent</h2>
+
+<p>To advertise which implicit intents your app can receive, declare one or more intent filters for
+each of your app components with an <a href=
+"{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter&gt;}</a>
+element in your <a href="{@docRoot}guide/topics/manifest/manifest-intro.html">manifest file</a>.
+Each intent filter specifies the type of intents it accepts based on the intent's action,
+data, and category. The system will deliver an implicit intent to your app component only if the
+intent can pass through one of your intent filters.</p>
+
+<p class="note"><strong>Note:</strong> An explicit intent is always delivered to its target,
+regardless of any intent filters the component declares.</p>
+
+<p>An app component should declare separate filters for each unique job it can do.
+For example, one activity in an image gallery app may have two filters: one filter
+to view an image, and another filter to edit an image. When the activity starts,
+it inspects the {@link android.content.Intent} and decides how to behave based on the information
+in the {@link android.content.Intent} (such as to show the editor controls or not).</p>
+
+<p>Each intent filter is defined by an <a
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>
+element in the app's manifest file, nested in the corresponding app component (such
+as an <a href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a>
+element). Inside the <a
+href="{@docRoot}guide/topics/manifest/intent-filter-element.html">{@code &lt;intent-filter>}</a>,
+you can specify the type of intents to accept using one or more
+of these three elements:</p>
+
+<dl>
+<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action>}</a></dt>
+  <dd>Declares the intent action accepted, in the {@code name} attribute. The value
+  must be the literal string value of an action, not the class constant.</dd>
+<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a></dt>
+  <dd>Declares the type of data accepted, using one or more attributes that specify various
+  aspects of the data URI (<code>scheme</code>, <code>host</code>, <code>port</code>,
+  <code>path</code>, etc.) and MIME type.</dd>
+<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category>}</a></dt>
+  <dd>Declares the intent category accepted, in the {@code name} attribute. The value
+  must be the literal string value of an action, not the class constant.
+
+  <p class="note"><strong>Note:</strong> In order to receive implicit intents, you
+  <strong>must include</strong> the
+  {@link android.content.Intent#CATEGORY_DEFAULT} category in the intent filter. The methods
+  {@link android.app.Activity#startActivity startActivity()} and
+  {@link android.app.Activity#startActivityForResult startActivityForResult()} treat all intents
+  as if they declared the {@link android.content.Intent#CATEGORY_DEFAULT} category.
+  If you do not declare this category in your intent filter, no implicit intents will resolve to
+  your activity.</p>
+  </dd>
+</dl>
+
+<p>For example, here's an activity declaration with an intent filter to receive an
+{@link android.content.Intent#ACTION_SEND} intent when the data type is text:</p>
+
+<pre>
+&lt;activity android:name="ShareActivity">
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.SEND"/>
+        &lt;category android:name="android.intent.category.DEFAULT"/>
+        &lt;data android:mimeType="text/plain"/>
+    &lt;/intent-filter>
+&lt;/activity>
+</pre>
+
+<p>It's okay to create a filter that includes more than one instance of
+<a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action>}</a>,
+<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a>, or
+<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category>}</a>.
+If you do, you simply need to be certain that the component can handle any and all combinations
+of those filter elements.</p>
+
+<p>When you want to handle multiple kinds of intents, but only in specific combinations of
+action, data, and category type, then you need to create multiple intent filters.</p>
+
 
 <div class="sidebox-wrapper">
 <div class="sidebox">
-<h2>Filters and security</h2>
-<p>An intent filter cannot be relied on for security.  While it opens a
-component to receiving only certain kinds of implicit intents, it does 
-nothing to prevent explicit intents from targeting the component.  Even 
-though a filter restricts the intents a component will be asked to handle
-to certain actions and data sources, someone could always put 
-together an explicit intent with a different action and data source, and 
-name the component as the target.
+<h2>Restricting access to components</h2>
+<p>Using an intent filter is not a secure way to prevent other apps from starting
+your components. Although intent filters restrict a component to respond to only
+certain kinds of implicit intents, another app can potentially start your app component
+by using an explicit intent if the developer determines your component names.
+If it's important that <em>only your own app</em> is able to start one of your components,
+set the <a href="{@docRoot}guide/topics/manifest/activity-element.html#exported">{@code
+exported}</a> attribute to {@code "false"} for that component.
 </p>
 </div>
-</div> 
+</div>
 
-<p>
-An intent filter is an instance of the {@link android.content.IntentFilter} class.  
-However, since the Android system must know about the capabilities of a component 
-before it can launch that component, intent filters are generally not set up in 
-Java code, but in the application's manifest file (AndroidManifest.xml) as 
-<code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> 
-elements.  (The one exception would be filters for 
-broadcast receivers that are registered dynamically by calling <code>{@link android.content.Context#registerReceiver(BroadcastReceiver, IntentFilter, String, 
-Handler) Context.registerReceiver()}</code>; they are directly created as 
-IntentFilter objects.)
-</p>
+<p>An implicit intent is tested against a filter by comparing the intent to each of the
+three elements. To be delivered to the component, the intent must pass all three tests.
+If it fails to match even one of them, the Android system won't deliver the intent to the
+component.  However, because a component may have multiple intent filters, an intent that does
+not pass through one of a component's filters might make it through on another filter.
+More information about how the system resolves intents is provided in the section below
+about <a href="#Resolution">Intent Resolution</a>.</p>
 
-<p>
-A filter has fields that parallel the action, data, and category fields of an 
-Intent object.  An implicit intent is tested against the filter in all three areas.  
-To be delivered to the component that owns the filter, it must pass all three tests.  
-If it fails even one of them, the Android system won't deliver it to the 
-component &mdash; at least not on the basis of that filter.  However, since a 
-component can have multiple intent filters, an intent that does not pass 
-through one of a component's filters might make it through on another.
-</p>
+<p class="caution"><strong>Caution:</strong> To avoid inadvertently running a different app's
+{@link android.app.Service}, always use an explicit intent to start your own service and do not
+declare intent filters for your service.</p>
 
-<p>
-Each of the three tests is described in detail below:
-</p>
+<p class="note"><strong>Note:</strong>
+For all activities, you must declare your intent filters in the manifest file.
+However, filters for broadcast receivers can be registered dynamically by calling
+{@link android.content.Context#registerReceiver(BroadcastReceiver, IntentFilter, String,
+Handler) registerReceiver()}. You can then unregister the receiver with {@link
+android.content.Context#unregisterReceiver unregisterReceiver()}. Doing so allows your app
+to listen for specific broadcasts during only a specified period of time while your app
+is running.</p>
 
-<dl>
 
-<dt><b>Action test</b></dt>
-<dd>An 
-<code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code>
-element in the manifest file lists actions as 
-<code><a href="{@docRoot}guide/topics/manifest/action-element.html">&lt;action&gt;</a></code> 
-subelements.  For example:
 
-<pre>&lt;intent-filter . . . &gt;
-    &lt;action android:name="com.example.project.SHOW_CURRENT" /&gt;
-    &lt;action android:name="com.example.project.SHOW_RECENT" /&gt;
-    &lt;action android:name="com.example.project.SHOW_PENDING" /&gt;
-    . . .
-&lt;/intent-filter&gt;</pre>
 
-<p>
-As the example shows, while an Intent object names just a single action, 
-a filter may list more than one.  The list cannot be empty; a filter must 
-contain at least one {@code &lt;action&gt;} element, or it
-will block all intents.
-</p>
 
-<p>
-To pass this test, the action specified in the Intent object must match 
-one of the actions listed in the filter.  If the object or the filter 
-does not specify an action, the results are as follows: 
-</p>
+
+
+<h3 id="ExampleFilters">Example filters</h3>
+
+<p>To better understand some of the intent filter behaviors, look at the following snippet
+from the manifest file of a social-sharing app.</p>
+
+<pre>
+&lt;activity android:name="MainActivity">
+    &lt;!-- This activity is the main entry, should appear in app launcher -->
+    &lt;intent-filter>
+        &lt;action android:name="android.intent.action.MAIN" />
+        &lt;category android:name="android.intent.category.LAUNCHER" />
+    &lt;/intent-filter>
+&lt;/activity>
+
+&lt;activity android:name="ShareActivity">
+    &lt;!-- This activity handles "SEND" actions with text data -->
+    &lt;intent-filter&gt;
+        &lt;action android:name="android.intent.action.SEND"/>
+        &lt;category android:name="android.intent.category.DEFAULT"/>
+        &lt;data android:mimeType="text/plain"/>
+    &lt;/intent-filter&gt;
+    &lt;!-- This activity also handles "SEND" and "SEND_MULTIPLE" with media data -->
+    &lt;intent-filter&gt;
+        &lt;action android:name="android.intent.action.SEND"/>
+        &lt;action android:name="android.intent.action.SEND_MULTIPLE"/>
+        &lt;category android:name="android.intent.category.DEFAULT"/>
+        &lt;data android:mimeType="application/vnd.google.panorama360+jpg"/>
+        &lt;data android:mimeType="image/*"/>
+        &lt;data android:mimeType="video/*"/>
+    &lt;/intent-filter&gt;
+&lt;/activity&gt;
+</pre>
+
+<p>The first activity, {@code MainActivity}, is the app's main entry point&mdash;the activity that
+opens when the user initially launches the app with the launcher icon:</p>
+<ul>
+  <li>The {@link android.content.Intent#ACTION_MAIN} action
+  indicates this is the main entry point and does not expect any intent data.</li>
+  <li>The {@link android.content.Intent#CATEGORY_LAUNCHER} category indicates that this activity's
+  icon should be placed in the system's app launcher. If the <a
+  href="{@docRoot}guide/topics/manifest/activity-element.html">{@code &lt;activity>}</a> element
+  does not specify an icon with {@code icon}, then the system uses the icon from the <a
+  href="{@docRoot}guide/topics/manifest/application-element.html">{@code &lt;application>}</a>
+  element.</li>
+</ul>
+<p>These two must be paired together in order for the activity to appear in the app launcher.</p>
+
+<p>The second activity, {@code ShareActivity}, is intended to facilitate sharing text and media
+content. Although users might enter this activity by navigating to it from {@code MainActivity},
+they can also enter {@code ShareActivity} directly from another app that issues an implicit
+intent matching one of the two intent filters.</p>
+
+<p class="note"><strong>Note:</strong> The MIME type,
+<a href="https://developers.google.com/panorama/android/">{@code
+application/vnd.google.panorama360+jpg}</a>, is a special data type that specifies
+panoramic photos, which you can handle with the <a
+href="{@docRoot}reference/com/google/android/gms/panorama/package-summary.html">Google
+panorama</a> APIs.</p>
+
+
+
+
+
+
+
+
+
+
+
+
+
+<h2 id="PendingIntent">Using a Pending Intent</h2>
+
+<p>A {@link android.app.PendingIntent} object is a wrapper around an {@link
+android.content.Intent} object. The primary purpose of a {@link android.app.PendingIntent}
+is to grant permission to a foreign application
+to use the contained {@link android.content.Intent} as if it were executed from your
+app's own process.</p>
+
+<p>Major use cases for a pending intent include:</p>
+<ul>
+  <li>Declare an intent to be executed when the user performs an action with your <a
+  href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Notification</a>
+  (the Android system's {@link android.app.NotificationManager}
+  executes the {@link android.content.Intent}).
+  <li>Declare an intent to be executed when the user performs an action with your
+  <a href="{@docRoot}guide/topics/appwidgets/index.html">App Widget</a>
+  (the Home screen app executes the {@link android.content.Intent}).
+  <li>Declare an intent to be executed at a specified time in the future (the Android
+  system's {@link android.app.AlarmManager} executes the {@link android.content.Intent}).
+</ul>
+
+<p>Because each {@link android.content.Intent} object is designed to be handled by a specific
+type of app component (either an {@link android.app.Activity}, a {@link android.app.Service}, or
+a {@link android.content.BroadcastReceiver}), so too must a {@link android.app.PendingIntent} be
+created with the same consideration. When using a pending intent, your app will not
+execute the intent with a call such as {@link android.content.Context#startActivity
+startActivity()}. You must instead declare the intended component type when you create the
+{@link android.app.PendingIntent} by calling the respective creator method:</p>
 
 <ul>
-<li>If the filter fails to list any actions, there is nothing for an 
-intent to match, so all intents fail the test.  No intents can get 
-through the filter.</li>
+  <li>{@link android.app.PendingIntent#getActivity PendingIntent.getActivity()} for an
+  {@link android.content.Intent} that starts an {@link android.app.Activity}.</li>
+  <li>{@link android.app.PendingIntent#getService PendingIntent.getService()} for an
+  {@link android.content.Intent} that starts a {@link android.app.Service}.</li>
+  <li>{@link android.app.PendingIntent#getBroadcast PendingIntent.getBroadcast()} for a
+  {@link android.content.Intent} that starts an {@link android.content.BroadcastReceiver}.</li>
+</ul>
 
-<li><p>On the other hand, an Intent object that doesn't specify an 
-action automatically passes the test &mdash; as long as the filter 
-contains at least one action.</p></li>
-</ul
-</dd>
+<p>Unless your app is <em>receiving</em> pending intents from other apps,
+the above methods to create a {@link android.app.PendingIntent} are the only
+{@link android.app.PendingIntent} methods you'll probably ever need.</p>
 
-<dt><b>Category test</b></dt>
-<dd>An 
-<code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> 
-element also lists categories as subelements.  For example:
+<p>Each method takes the current app {@link android.content.Context}, the
+{@link android.content.Intent} you want to wrap, and one or more flags that specify
+how the intent should be used (such as whether the intent can be used more than once).</p>
 
-<pre>&lt;intent-filter . . . &gt;
+<p>More information about using pending intents is provided with the documentation for each
+of the respective use cases, such as in the <a
+href="{@docRoot}guide/topics/ui/notifiers/notifications.html">Notifications</a>
+and <a href="{@docRoot}guide/topics/appwidgets/index.html">App Widgets</a> API guides.</p>
+
+
+
+
+
+
+
+<h2 id="Resolution">Intent Resolution</h2>
+
+
+<p>When the system receives an implicit intent to start an activity, it searches for the
+best activity for the intent by comparing the intent to intent filters based on three aspects:</p>
+
+<ul>
+  <li>The intent action
+  <li>The intent data (both URI and data type)
+  <li>The intent category
+</ul>
+
+<p>The following sections describe how an intents are matched to the appropriate component(s)
+in terms of how the intent filter is declared in an app's manifest file.</p>
+
+
+<h3 id="ActionTest">Action test</h3>
+
+<p>To specify accepted intent actions, an intent filter can declare zero or more
+<a href="{@docRoot}guide/topics/manifest/action-element.html">{@code
+&lt;action&gt;}</a> elements.  For example:</p>
+
+<pre>
+&lt;intent-filter&gt;
+    &lt;action android:name="android.intent.action.EDIT" /&gt;
+    &lt;action android:name="android.intent.action.VIEW" /&gt;
+    ...
+&lt;/intent-filter&gt;
+</pre>
+
+<p>To get through this filter, the action specified in the {@link android.content.Intent}
+  must match one of the actions listed in the filter.</p>
+
+<p>If the filter does not list any actions, there is nothing for an
+intent to match, so all intents fail the test. However, if an {@link android.content.Intent}
+does not specify an action, it will pass the test (as long as the filter
+contains at least one action).</p>
+
+
+
+<h3 id="CategoryTest">Category test</h3>
+
+<p>To specify accepted intent categories, an intent filter can declare zero or more
+<a href="{@docRoot}guide/topics/manifest/category-element.html">{@code
+&lt;category&gt;}</a> elements.  For example:</p>
+
+<pre>
+&lt;intent-filter&gt;
     &lt;category android:name="android.intent.category.DEFAULT" /&gt;
     &lt;category android:name="android.intent.category.BROWSABLE" /&gt;
-    . . .
-&lt;/intent-filter&gt;</pre>
+    ...
+&lt;/intent-filter&gt;
+</pre>
 
-<p>
-Note that the constants described earlier for actions and categories are not
-used in the manifest file.  The full string values are used instead.  For 
-instance, the "{@code android.intent.category.BROWSABLE}" string in the example 
-above corresponds to the {@code CATEGORY_BROWSABLE} constant mentioned earlier 
-in this document.  Similarly, the string "{@code android.intent.action.EDIT}" 
-corresponds to the {@code ACTION_EDIT} constant.
+<p>For an intent to pass the category test, every category in the {@link android.content.Intent}
+must match a category in the filter. The reverse is not necessary&mdash;the intent filter may
+declare more categories than are specified in the {@link android.content.Intent} and the
+{@link android.content.Intent} will still pass. Therefore, an intent with no categories should
+always pass this test, regardless of what categories are declared in the filter.</p>
+
+<p class="note"><strong>Note:</strong>
+Android automatically applies the the {@link android.content.Intent#CATEGORY_DEFAULT} category
+to all implicit intents passed to {@link
+android.content.Context#startActivity startActivity()} and {@link
+android.app.Activity#startActivityForResult startActivityForResult()}.
+So if you want your activity to receive implicit intents, it must
+include a category for {@code "android.intent.category.DEFAULT"} in its intent filters (as
+shown in the previous {@code &lt;intent-filter>} example.</p>
+
+
+
+<h3 id="DataTest">Data test</h3>
+
+<p>To specify accepted intent data, an intent filter can declare zero or more
+<a href="{@docRoot}guide/topics/manifest/data-element.html">{@code
+&lt;data&gt;}</a> elements.  For example:</p>
+
+<pre>
+&lt;intent-filter&gt;
+    &lt;data android:mimeType="video/mpeg" android:scheme="http" ... /&gt;
+    &lt;data android:mimeType="audio/mpeg" android:scheme="http" ... /&gt;
+    ...
+&lt;/intent-filter&gt;
+</pre>
+
+<p>Each <code><a href="{@docRoot}guide/topics/manifest/data-element.html">&lt;data&gt;</a></code>
+element can specify a URI structure and a data type (MIME media type).  There are separate
+attributes &mdash; {@code scheme}, {@code host}, {@code port},
+and {@code path} &mdash; for each part of the URI:
 </p>
 
-<p>
-For an intent to pass the category test, every category in the Intent object 
-must match a category in the filter.  The filter can list additional categories, 
-but it cannot omit any that are in the intent.
-</p>
+<p style="margin-left: 2em">{@code &lt;scheme>://&lt;host>:&lt;port>/&lt;path>}</p>
 
 <p>
-In principle, therefore, an Intent object with no categories should always pass 
-this test, regardless of what's in the filter.  That's mostly true.  However, 
-with one exception, Android treats all implicit intents passed to {@link 
-android.content.Context#startActivity startActivity()} as if they contained 
-at least one category:  "{@code android.intent.category.DEFAULT}" (the
-{@code CATEGORY_DEFAULT} constant).  
-Therefore, activities that are willing to receive implicit intents must 
-include "{@code android.intent.category.DEFAULT}" in their intent filters. 
-(Filters with "{@code android.intent.action.MAIN}" and 
-"{@code android.intent.category.LAUNCHER}" settings are the exception.  
-They mark activities that begin new tasks and that are represented on the 
-launcher screen.  They can include "{@code android.intent.category.DEFAULT}" 
-in the list of categories, but don't need to.)  See <a href="#imatch">Using
-intent matching</a>, later, for more on these filters.)
-</p>
-<dd>
-
-<dt><b>Data test</b></dt>
-<dd>Like the action and categories, the data specification for an intent filter 
-is contained in a subelement.  And, as in those cases, the subelement can appear 
-multiple times, or not at all.  For example:
-
-<pre>&lt;intent-filter . . . &gt;
-    &lt;data android:mimeType="video/mpeg" android:scheme="http" . . . /&gt; 
-    &lt;data android:mimeType="audio/mpeg" android:scheme="http" . . . /&gt;
-    . . .
-&lt;/intent-filter&gt;</pre>
-
-<p>
-Each 
-<code><a href="{@docRoot}guide/topics/manifest/data-element.html">&lt;data&gt;</a></code> 
-element can specify a URI and a data type (MIME media type).  There are separate 
-attributes &mdash; {@code scheme}, {@code host}, {@code port}, 
-and {@code path} &mdash; for each part of the URI:  
-</p>
-
-<p style="margin-left: 2em">{@code scheme://host:port/path}</p>
-
-<p>
-For example, in the following URI,
+For example:
 </p>
 
 <p style="margin-left: 2em">{@code content://com.example.project:200/folder/subfolder/etc}</p>
 
-<p> the scheme is "{@code content}", the host is "{@code com.example.project}", 
-the port is "{@code 200}", and the path is "{@code folder/subfolder/etc}".  
-The host and port together constitute the URI <i>authority</i>; if a host is 
-not specified, the port is ignored.
+<p>In this URI, the scheme is {@code content}, the host is {@code com.example.project},
+the port is {@code 200}, and the path is {@code folder/subfolder/etc}.
 </p>
 
-<p>
-Each of these attributes is optional, but they are not independent of each other:  
-For an authority to be meaningful, a scheme must also be specified.  
-For a path to be meaningful, both a scheme and an authority must be specified.  
-</p>
+<p>Each of these attributes is optional in a <a
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a> element,
+but there are linear dependencies:</p>
+<ul>
+  <li>If a scheme is not specified, the host is ignored.</li>
+  <li>If a host is not specified, the port is ignored.</li>
+  <li>If both the scheme and host are not specified, the path is ignored.</li>
+</ul>
 
-<p>
-When the URI in an Intent object is compared to a URI specification in a filter, 
-it's compared only to the parts of the URI actually mentioned in the filter.  
-For example, if a filter specifies only a scheme, all URIs with that scheme match 
-the filter.  If a filter specifies a scheme and an authority but no path, all URIs 
-with the same scheme and authority match, regardless of their paths.  If a filter 
-specifies a scheme, an authority, and a path, only URIs with the same scheme, 
-authority, and path match.  However, a path specification in the filter can 
-contain wildcards to require only a partial match of the path.
-</p>
+<p>When the URI in an intent is compared to a URI specification in a filter,
+it's compared only to the parts of the URI included in the filter. For example:</p>
+<ul>
+  <li>If a filter specifies only a scheme, all URIs with that scheme match
+the filter.</li>
+  <li>If a filter specifies a scheme and an authority but no path, all URIs
+with the same scheme and authority pass the filter, regardless of their paths.</li>
+  <li>If a filter specifies a scheme, an authority, and a path, only URIs with the same scheme,
+authority, and path pass the filter.</li>
+</ul>
 
-<p>
-The {@code type} attribute of a {@code &lt;data&gt;} element specifies the MIME type 
-of the data.  It's more common in filters than a URI.  Both the Intent object and 
-the filter can use a "*" wildcard for the subtype field &mdash; for example, 
-"{@code text/*}" or "{@code audio/*}" &mdash; indicating any subtype matches.
-</p>
+<p class="note"><strong>Note:</strong> A path specification can
+contain a wildcard asterisk (*) to require only a partial match of the path name.</p>
 
-<p>
-The data test compares both the URI and the data type in the Intent object to a URI 
-and data type specified in the filter.  The rules are as follows:
+<p>The data test compares both the URI and the MIME type in the intent to a URI
+and MIME type specified in the filter.  The rules are as follows:
 </p>
 
 <ol type="a">
-<li>An Intent object that contains neither a URI nor a data type passes the 
-test only if the filter likewise does not specify any URIs or data types.</li>
+<li>An intent that contains neither a URI nor a MIME type passes the
+test only if the filter does not specify any URIs or MIME types.</li>
 
-<li><p>An Intent object that contains a URI but no data type (and a type cannot 
-be inferred from the URI) passes the test only if its URI matches a URI in the 
-filter and the filter likewise does not specify a type.  This will be the case 
-only for URIs like {@code mailto:} and {@code tel:} that do not refer to actual data.</p></li>
+<li>An intent that contains a URI but no MIME type (neither explicit nor inferable from the
+URI) passes the test only if its URI matches the filter's URI format
+and the filter likewise does not specify a MIME type.</li>
 
-<li><p>An Intent object that contains a data type but not a URI passes the test 
-only if the filter lists the same data type and similarly does not specify a URI.</p></li>
+<li>An intent that contains a MIME type but not a URI passes the test
+only if the filter lists the same MIME type and does not specify a URI format.</li>
 
-<li><p>An Intent object that contains both a URI and a data type (or a data type 
-can be inferred from the URI) passes the data type part of the test only if its 
-type matches a type listed in the filter.  It passes the URI part of the test 
-either if its URI matches a URI in the filter or if it has a {@code content:} 
-or {@code file:} URI and the filter does not specify a URI.  In other words, 
+<li>An intent that contains both a URI and a MIME type (either explicit or inferable from the
+URI) passes the MIME type part of the test only if that
+type matches a type listed in the filter.  It passes the URI part of the test
+either if its URI matches a URI in the filter or if it has a {@code content:}
+or {@code file:} URI and the filter does not specify a URI.  In other words,
 a component is presumed to support {@code content:} and {@code file:} data if
-its filter lists only a data type.</p></li>
+its filter lists <em>only</em> a MIME type.</p></li>
 </ol>
-</dl>
 
 <p>
-If an intent can pass through the filters of more than one activity or service, 
-the user may be asked which component to activate.  An exception is raised if
-no target can be found.
-</p>
-
-
-<h3><a name="ccases"></a>Common cases</h3>
-
-<p>
-The last rule shown above for the data test, rule (d), reflects the expectation 
+This last rule, rule (d), reflects the expectation
 that components are able to get local data from a file or content provider.
 Therefore, their filters can list just a data type and do not need to explicitly
 name the {@code content:} and {@code file:} schemes.
-This is a typical case.  A {@code &lt;data&gt;} element like the following, 
-for example, tells Android that the component can get image data from a content 
+This is a typical case.  A <a
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a> element
+like the following, for example, tells Android that the component can get image data from a content
 provider and display it:
 </p>
 
-<pre>&lt;data android:mimeType="image/*" /&gt;</pre>
+<pre>
+&lt;intent-filter&gt;
+    &lt;data android:mimeType="image/*" /&gt;
+    ...
+&lt;/intent-filter&gt;</pre>
 
 <p>
-Since most available data is dispensed by content providers, filters that 
+Because most available data is dispensed by content providers, filters that
 specify a data type but not a URI are perhaps the most common.
 </p>
 
 <p>
 Another common configuration is filters with a scheme and a data type.  For
-example, a {@code &lt;data&gt;} element like the following tells Android that
-the component can get video data from the network and display it:
+example, a <a
+href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data>}</a>
+element like the following tells Android that
+the component can retrieve video data from the network in order to perform the action:
 </p>
 
-<pre>&lt;data android:scheme="http" android:type="video/*" /&gt;</pre>
-
-<p>
-Consider, for example, what the browser application does when
-the user follows a link on a web page.   It first tries to display the data 
-(as it could if the link was to an HTML page).  If it can't display the data, 
-it puts together an implicit intent with the scheme and data type and tries
-to start an activity that can do the job.  If there are no takers, it asks the
-download manager to download the data.  That puts it under the control
-of a content provider, so a potentially larger pool of activities
-(those with filters that just name a data type) can respond.
-</p>
-
-<p>
-Most applications also have a way to start fresh, without a reference
-to any particular data.  Activities that can initiate applications 
-have filters with "{@code android.intent.action.MAIN}" specified as
-the action.  If they are to be represented in the application launcher,
-they also specify the "{@code android.intent.category.LAUNCHER}" 
-category:
-</p>
-
-<pre>&lt;intent-filter . . . &gt;
-    &lt;action android:name="android.intent.action.MAIN" /&gt;
-    &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
+<pre>
+&lt;intent-filter&gt;
+    &lt;data android:scheme="http" android:type="video/*" /&gt;
+    ...
 &lt;/intent-filter&gt;</pre>
 
 
-<h3><a name="imatch"></a>Using intent matching</h3>
 
-<p>
-Intents are matched against intent filters not only to discover a target
+<h3 id="imatch">Intent matching</h3>
+
+<p>Intents are matched against intent filters not only to discover a target
 component to activate, but also to discover something about the set of
-components on the device.  For example, the Android system populates the 
-application launcher, the top-level screen that shows the applications 
-that are available for the user to launch, by finding all the  activities
- with intent filters that specify the "{@code android.intent.action.MAIN}" 
-action and "{@code android.intent.category.LAUNCHER}" category 
-(as illustrated in the previous section).  It then displays the icons and 
-labels of those activities in the launcher.  Similarly, it discovers the 
-home screen by looking for the activity with 
-"{@code android.intent.category.HOME}" in its filter.
-</p>
+components on the device.  For example, the Home app populates the app launcher
+by finding all the  activities with intent filters that specify the
+{@link android.content.Intent#ACTION_MAIN} action and
+{@link android.content.Intent#CATEGORY_LAUNCHER} category.</p>
 
-<p>
-Your application can use intent matching is a similar way.
+<p>Your application can use intent matching in a similar way.
 The {@link android.content.pm.PackageManager} has a set of {@code query...()}
-methods that return all components that can accept a particular intent, and 
+methods that return all components that can accept a particular intent, and
 a similar series of {@code resolve...()} methods that determine the best
-component to respond to an intent.  For example, 
-{@link android.content.pm.PackageManager#queryIntentActivities 
+component to respond to an intent.  For example,
+{@link android.content.pm.PackageManager#queryIntentActivities
 queryIntentActivities()} returns a list of all activities that can perform
-the intent passed as an argument, and {@link 
-android.content.pm.PackageManager#queryIntentServices 
-queryIntentServices()} returns a similar list of services.  
+the intent passed as an argument, and {@link
+android.content.pm.PackageManager#queryIntentServices
+queryIntentServices()} returns a similar list of services.
 Neither method activates the components; they just list the ones that
-can respond.  There's a similar method, 
-{@link android.content.pm.PackageManager#queryBroadcastReceivers 
+can respond.  There's a similar method,
+{@link android.content.pm.PackageManager#queryBroadcastReceivers
 queryBroadcastReceivers()}, for broadcast receivers.
 </p>
 
-<h2 id="npex">Note Pad Example</h2>
-
-<p>
-The Note Pad sample application enables users to browse through a list 
-of notes, view details about individual items in the list, edit the items, 
-and add a new item to the list.  This section looks at the intent filters
-declared in its manifest file.  (If you're working offline in the SDK, you 
-can find all the source files for this sample application, including its 
-manifest file, at {@code &lt;sdk&gt;/samples/NotePad/index.html}.  
-If you're viewing the documentation online, the source files are in the 
-<a href="{@docRoot}resources/samples/index.html">Tutorials and Sample Code</a> 
-section <a href="{@docRoot}resources/samples/NotePad/index.html">here</a>.)
-</p>
-
-<p>
-In its manifest file, the Note Pad application declares three activities,
-each with at least one intent filter.  It also declares a content provider 
-that manages the note data.  Here is the manifest file in its entirety:
-</p>
-
-<pre>&lt;manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.example.android.notepad"&gt;
-    &lt;application android:icon="@drawable/app_notes"
-                 android:label="@string/app_name" &gt;
-
-        &lt;provider android:name="NotePadProvider"
-                  android:authorities="com.google.provider.NotePad" /&gt;
-
-        &lt;activity android:name="NotesList" android:label="@string/title_notes_list"&gt;
-            &lt;intent-filter&gt;
-                &lt;action android:name="android.intent.action.MAIN" /&gt;
-                &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
-            &lt;/intent-filter&gt;
-            &lt;intent-filter&gt;
-                &lt;action android:name="android.intent.action.VIEW" /&gt;
-                &lt;action android:name="android.intent.action.EDIT" /&gt;
-                &lt;action android:name="android.intent.action.PICK" /&gt;
-                &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-                &lt;data android:mimeType="vnd.android.cursor.dir/vnd.google.note" /&gt;
-            &lt;/intent-filter&gt;
-            &lt;intent-filter&gt;
-                &lt;action android:name="android.intent.action.GET_CONTENT" /&gt;
-                &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-                &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-            &lt;/intent-filter&gt;
-        &lt;/activity&gt;
-        
-        &lt;activity android:name="NoteEditor"
-                  android:theme="@android:style/Theme.Light"
-                  android:label="@string/title_note" &gt;
-            &lt;intent-filter android:label="@string/resolve_edit"&gt;
-                &lt;action android:name="android.intent.action.VIEW" /&gt;
-                &lt;action android:name="android.intent.action.EDIT" /&gt;
-                &lt;action android:name="com.android.notepad.action.EDIT_NOTE" /&gt;
-                &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-                &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-            &lt;/intent-filter&gt;
-            &lt;intent-filter&gt;
-                &lt;action android:name="android.intent.action.INSERT" /&gt;
-                &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-                &lt;data android:mimeType="vnd.android.cursor.dir/vnd.google.note" /&gt;
-            &lt;/intent-filter&gt;
-        &lt;/activity&gt;
-        
-        &lt;activity android:name="TitleEditor" 
-                  android:label="@string/title_edit_title"
-                  android:theme="@android:style/Theme.Dialog"&gt;
-            &lt;intent-filter android:label="@string/resolve_title"&gt;
-                &lt;action android:name="com.android.notepad.action.EDIT_TITLE" /&gt;
-                &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-                &lt;category android:name="android.intent.category.ALTERNATIVE" /&gt;
-                &lt;category android:name="android.intent.category.SELECTED_ALTERNATIVE" /&gt;
-                &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-            &lt;/intent-filter&gt;
-        &lt;/activity&gt;
-        
-    &lt;/application&gt;
-&lt;/manifest&gt;</pre>
-
-<p>
-The first activity, NotesList, is 
-distinguished from the other activities by the fact that it operates 
-on a directory of notes (the note list) rather than on a single note.  
-It would generally serve as the initial user interface into the 
-application.  It can do three things as described by its three intent 
-filters:
-</p>
-
-<ol>
-<li><pre>&lt;intent-filter&gt;
-    &lt;action android:name="android.intent.action.MAIN" /&gt;
-    &lt;category android:name="android.intent.category.LAUNCHER" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-This filter declares the main entry point into the Note Pad application.  
-The standard {@code MAIN} action is an entry point that does not require 
-any other information in the Intent (no data specification, for example), 
-and the {@code LAUNCHER} category says that this entry point should be 
-listed in the application launcher.
-</p></li>
-
-<li><pre>&lt;intent-filter&gt;
-    &lt;action android:name="android.intent.action.VIEW" /&gt;
-    &lt;action android:name="android.intent.action.EDIT" /&gt;
-    &lt;action android:name="android.intent.action.PICK" /&gt;
-    &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-    &lt;data android:mimeType="vnd.android.cursor.dir/vnd.google.note" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-This filter declares the things that the activity can do on a directory 
-of notes.  It can allow the user to view or edit the directory (via
-the {@code VIEW} and {@code EDIT} actions), or to pick a particular note 
-from the directory (via the {@code PICK} action).
-</p> 
-
-<p>
-The {@code mimeType} attribute of the 
-<code><a href="{@docRoot}guide/topics/manifest/data-element.html">&lt;data&gt;</a></code> 
-element specifies the kind of data that these actions operate on.  It 
-indicates that the activity can get a Cursor over zero or more items 
-({@code vnd.android.cursor.dir}) from a content provider that holds
-Note Pad data ({@code vnd.google.note}).  The Intent object that launches
-the activity would include a {@code content:} URI specifying the exact 
-data of this type that the activity should open.
-</p>
-
-<p>
-Note also the {@code DEFAULT} category supplied in this filter.  It's
-there because the <code>{@link android.content.Context#startActivity  
-Context.startActivity()}</code> and 
-<code>{@link android.app.Activity#startActivityForResult  
-Activity.startActivityForResult()}</code> methods treat all intents 
-as if they contained the {@code DEFAULT} category &mdash; with just
-two exceptions:
-</p>
-
-<ul>
-<li>Intents that explicitly name the target activity</li>
-<li>Intents consisting of the {@code MAIN} action and {@code LAUNCHER} 
-category</li>
-</ul>
-
-<p>
-Therefore, the {@code DEFAULT} category is <em>required</em> for all 
-filters &mdash; except for those with the {@code MAIN} action and 
-{@code LAUNCHER} category.  (Intent filters are not consulted for
-explicit intents.)  
-</p></li>
-
-<li><pre>&lt;intent-filter&gt;
-    &lt;action android:name="android.intent.action.GET_CONTENT" /&gt;
-    &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-    &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-This filter describes the activity's ability to return a note selected by
-the user without requiring any specification of the directory the user should 
-choose from.  The {@code GET_CONTENT} action is similar to the {@code PICK} 
-action.  In both cases, the activity returns the URI for a note selected by 
-the user.  (In each case, it's returned to the activity that called
-<code>{@link android.app.Activity#startActivityForResult 
-startActivityForResult()}</code> to start the NoteList activity.)  Here, 
-however, the caller specifies the type of data desired instead of the 
-directory of data the user will be picking from.
-</p>
-
-<p>
-The data type, <code>vnd.android.cursor.item/vnd.google.note</code>, 
-indicates the type of data the activity can return &mdash; a URI for 
-a single note.  From the returned URI, the caller can get a Cursor for 
-exactly one item ({@code vnd.android.cursor.item}) from the content 
-provider that holds Note Pad data ({@code vnd.google.note}).
-</p>
-
-<p>
-In other words, for the {@code PICK} action in the previous filter, 
-the data type indicates the type of data the activity could display to the 
-user.  For the {@code GET_CONTENT} filter, it indicates the type of data 
-the activity can return to the caller.
-</p></li>
-</ol>
-
-<p>
-Given these capabilities, the following intents will resolve to the
-NotesList activity:
-</p>
-
-<dl style="margin-left: 2em">
-<dt>action: <code>android.intent.action.MAIN</code></dt>
-<dd>Launches the activity with no data specified.</dd>
-
-<dt>action: <code>android.intent.action.MAIN</code>
-<br/>category: <code>android.intent.category.LAUNCHER</code></dt>
-<dd> Launches the activity with no data selected specified. 
-This is the actual intent used by the Launcher to populate its top-level 
-list.  All activities with filters that match this action and category
-are added to the list.</dd>
-
-<dt>action: <code>android.intent.action.VIEW</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes</code></dt>
-<dd>Asks the activity to display a list of all the notes under
-<code>content://com.google.provider.NotePad/notes</code>.  The user can then 
-browse through the list and get information about the items in it.</dd>
-
-<dt>action: <code>android.intent.action.PICK</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes</code></dt>
-<dd>Asks the activity to display a list of the notes under
-<code>content://com.google.provider.NotePad/notes</code>.
-The user can then pick a note from the list, and the activity will return 
-the URI for that item back to the activity that started the NoteList activity.</dd>
-
-<dt>action: <code>android.intent.action.GET_CONTENT</code>
-<br/>data type: <code>vnd.android.cursor.item/vnd.google.note</code></dt>
-<dd>Asks the activity to supply a single item of Note Pad data.</dd>
-</dl>
-
-<p>
-The second activity, NoteEditor, shows 
-users a single note entry and allows them to edit it.  It can do two things 
-as described by its two intent filters:
-
-<ol>
-<li><pre>&lt;intent-filter android:label="@string/resolve_edit"&gt;
-    &lt;action android:name="android.intent.action.VIEW" /&gt;
-    &lt;action android:name="android.intent.action.EDIT" /&gt;
-    &lt;action android:name="com.android.notepad.action.EDIT_NOTE" /&gt;
-    &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-    &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-The first, primary, purpose of this activity is to enable the user to 
-interact with a single note &mdash; to either {@code VIEW} the note or 
-{@code EDIT} it.  (The {@code EDIT_NOTE} category is a synonym for 
-{@code EDIT}.)  The intent would contain the URI for data matching the 
-MIME type <code>vnd.android.cursor.item/vnd.google.note</code> &mdash;
-that is, the URI for a single, specific note.  It would typically be a 
-URI that was returned by the {@code PICK} or {@code GET_CONTENT} 
-actions of the NoteList activity.
-</p>
-
-<p>
-As before, this filter lists the {@code DEFAULT} category so that the 
-activity can be launched by intents that don't explicitly specify the
-NoteEditor class.
-</p></li>
-
-<li><pre>&lt;intent-filter&gt;
-    &lt;action android:name="android.intent.action.INSERT" /&gt;
-    &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-    &lt;data android:mimeType="vnd.android.cursor.dir/vnd.google.note" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-The secondary purpose of this activity is to enable the user to create a new 
-note, which it will {@code INSERT} into an existing directory of notes.  The 
-intent would contain the URI for data matching the MIME type
-<code>vnd.android.cursor.dir/vnd.google.note</code> &mdash; that 
-is, the URI for the directory where the note should be placed.
-</p></li>  
-</ol>
-
-<p>
-Given these capabilities, the following intents will resolve to the
-NoteEditor activity:
-</p>
-
-<dl style:"margin-left: 2em">
-<dt>action: <code>android.intent.action.VIEW</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes/<var>ID</var></code></dt>
-<dd>Asks the activity to display the content of the note identified 
-by {@code <var>ID</var>}. (For details on how {@code content:} URIs
-specify individual members of a group, see 
-<a href="{@docRoot}guide/topics/providers/content-providers.html">Content Providers</a>.)
-
-<dt>action: <code>android.intent.action.EDIT</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes/<var>ID</var></code></dt>
-<dd>Asks the activity to display the content of the note identified 
-by {@code <var>ID</var>}, and to let the user edit it.  If the user 
-saves the changes, the activity updates the data for the note in the 
-content provider.</dd>
-
-<dt>action: <code>android.intent.action.INSERT</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes</code></dt>
-<dd>Asks the activity to create a new, empty note in the notes list at
-<code>content://com.google.provider.NotePad/notes</code>
-and allow the user to edit it.  If the user saves the note, its URI
-is returned to the caller.
-</dd>
-</dl>
-
-<p>The last activity, TitleEditor, 
-enables the user to edit the title of a note.  This could be implemented 
-by directly invoking the activity (by explicitly setting its component 
-name in the Intent), without using an intent filter.  But here we take 
-the opportunity to show how to publish alternative operations on existing 
-data:
-</p>
-
-<pre>&lt;intent-filter android:label="@string/resolve_title"&gt;
-    &lt;action android:name="com.android.notepad.action.EDIT_TITLE" /&gt;
-    &lt;category android:name="android.intent.category.DEFAULT" /&gt;
-    &lt;category android:name="android.intent.category.ALTERNATIVE" /&gt;
-    &lt;category android:name="android.intent.category.SELECTED_ALTERNATIVE" /&gt;
-    &lt;data android:mimeType="vnd.android.cursor.item/vnd.google.note" /&gt;
-&lt;/intent-filter&gt;</pre>
-
-<p>
-The single intent filter for this activity uses a custom action called
-"<code>com.android.notepad.action.EDIT_TITLE</code>".  It must be invoked on
-a specific note (data type <code>vnd.android.cursor.item/vnd.google.note</code>),
-like the previous {@code VIEW} and {@code EDIT} actions.  However, here the 
-activity displays the title contained in the note data, not the content of 
-the note itself.
-</p>
-
-<p>
-In addition to supporting the usual {@code DEFAULT} category, the title 
-editor also supports two other standard categories: 
-<code>{@link android.content.Intent#CATEGORY_ALTERNATIVE ALTERNATIVE}</code>
-and <code>{@link android.content.Intent#CATEGORY_SELECTED_ALTERNATIVE 
-SELECTED_ALTERNATIVE}</code>.
-These categories identify activities that can be presented to users in 
-a menu of options (much as the {@code LAUNCHER} category identifies 
-activities that should be presented to user in the application launcher).  
-Note that the filter also supplies an explicit label (via 
-<code>android:label="@string/resolve_title"</code>) to better control
-what users see when presented with this activity as an alternative
-action to the data they are currently viewing.  (For more information 
-on these categories and building options menus, see the 
-<code>{@link android.content.pm.PackageManager#queryIntentActivityOptions 
-PackageManager.queryIntentActivityOptions()}</code> and 
-<code>{@link android.view.Menu#addIntentOptions Menu.addIntentOptions()}</code>
-methods.)
-</p>
-
-<p>
-Given these capabilities, the following intent will resolve to the
-TitleEditor activity:
-</p>
-
-<dl style="margin-left: 2em">
-<dt>action: <code>com.android.notepad.action.EDIT_TITLE</code>
-<br/>data: <code>content://com.google.provider.NotePad/notes/<var>ID</var></code></dt>
-<dd>Asks the activity to display the title associated with note <var>ID</var>, and 
-allow the user to edit the title.</dd>
-</dl>
-
-
-
-
-
-
-  
-
 
 
 
diff --git a/docs/html/guide/components/services.jd b/docs/html/guide/components/services.jd
index 30da33a..da01d2c 100644
--- a/docs/html/guide/components/services.jd
+++ b/docs/html/guide/components/services.jd
@@ -212,41 +212,35 @@
 &lt;/manifest&gt;
 </pre>
 
+<p>See the <a
+href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element
+reference for more information about declaring your service in the manifest.</p>
+
 <p>There are other attributes you can include in the <a
 href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element to
 define properties such as permissions required to start the service and the process in
 which the service should run. The <a
 href="{@docRoot}guide/topics/manifest/service-element.html#nm">{@code android:name}</a>
 attribute is the only required attribute&mdash;it specifies the class name of the service. Once
-you publish your application, you should not change this name, because if you do, you might break
-some functionality where explicit intents are used to reference your service (read the blog post, <a
+you publish your application, you should not change this name, because if you do, you risk breaking
+code due to dependence on explicit intents to start or bind the service (read the blog post, <a
 href="http://android-developers.blogspot.com/2011/06/things-that-cannot-change.html">Things
 That Cannot Change</a>).
 
-<p>See the <a
-href="{@docRoot}guide/topics/manifest/service-element.html">{@code &lt;service&gt;}</a> element
-reference for more information about declaring your service in the manifest.</p>
+<p>To ensure your app is secure, <strong>always use an explicit intent when starting or binding
+your {@link android.app.Service}</strong> and do not declare intent filters for the service. If
+it's critical that you allow for some amount of ambiguity as to which service starts, you can
+supply intent filters for your services and exclude the component name from the {@link
+android.content.Intent}, but you then must set the package for the intent with {@link
+android.content.Intent#setPackage setPackage()}, which provides sufficient disambiguation for the
+target service.</p>
 
-<p>Just like an activity, a service can define intent filters that allow other components to
-invoke the service using implicit intents. By declaring intent filters, components
-from any application installed on the user's device can potentially start your service if your
-service declares an intent filter that matches the intent another application passes to {@link
-android.content.Context#startService startService()}.</p>
-
-<p>If you plan on using your service only locally (other applications do not use it), then you
-don't need to (and should not) supply any intent filters. Without any intent filters, you must
-start the service using an intent that explicitly names the service class. More information
-about <a href="#StartingAService">starting a service</a> is discussed below.</p>
-
-<p>Additionally, you can ensure that your service is private to your application only if
-you include the <a
+<p>Additionally, you can ensure that your service is available to only your app by
+including the <a
 href="{@docRoot}guide/topics/manifest/service-element.html#exported">{@code android:exported}</a>
-attribute and set it to {@code "false"}. This is effective even if your service supplies intent
-filters.</p>
+attribute and setting it to {@code "false"}. This effectively stops other apps from starting your
+service, even when using an explicit intent.</p>
 
-<p>For more information about creating intent filters for your service, see the <a
-href="{@docRoot}guide/components/intents-filters.html">Intents and Intent Filters</a>
-document.</p>
 
 
 
@@ -333,7 +327,7 @@
 <pre>
 public class HelloIntentService extends IntentService {
 
-  /** 
+  /**
    * A constructor is required, and must call the super {@link android.app.IntentService#IntentService}
    * constructor with a name for the worker thread.
    */
@@ -443,8 +437,8 @@
     HandlerThread thread = new HandlerThread("ServiceStartArguments",
             Process.THREAD_PRIORITY_BACKGROUND);
     thread.start();
-    
-    // Get the HandlerThread's Looper and use it for our Handler 
+
+    // Get the HandlerThread's Looper and use it for our Handler
     mServiceLooper = thread.getLooper();
     mServiceHandler = new ServiceHandler(mServiceLooper);
   }
@@ -458,7 +452,7 @@
       Message msg = mServiceHandler.obtainMessage();
       msg.arg1 = startId;
       mServiceHandler.sendMessage(msg);
-      
+
       // If we get killed, after returning from here, restart
       return START_STICKY;
   }
@@ -468,10 +462,10 @@
       // We don't provide binding, so return null
       return null;
   }
-  
+
   &#64;Override
   public void onDestroy() {
-    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show(); 
+    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
   }
 }
 </pre>
@@ -652,7 +646,7 @@
 <h2 id="Foreground">Running a Service in the Foreground</h2>
 
 <p>A foreground service is a service that's considered to be something the
-user is actively aware of and thus not a candidate for the system to kill when low on memory. A 
+user is actively aware of and thus not a candidate for the system to kill when low on memory. A
 foreground service must provide a notification for the status bar, which is placed under the
 "Ongoing" heading, which means that the notification cannot be dismissed unless the service is
 either stopped or removed from the foreground.</p>
diff --git a/docs/html/guide/guide_toc.cs b/docs/html/guide/guide_toc.cs
index 8f2795a..6a2b1ba 100644
--- a/docs/html/guide/guide_toc.cs
+++ b/docs/html/guide/guide_toc.cs
@@ -68,9 +68,16 @@
             </a></li>
         </ul>
       </li>
-      <li><a href="<?cs var:toroot ?>guide/components/intents-filters.html">
-          <span class="en">Intents and Intent Filters</span>
-        </a></li>
+      <li class="nav-section">
+        <div class="nav-section-header"><a href="<?cs var:toroot ?>guide/components/intents-filters.html">
+            <span class="en">Intents and Intent Filters</span>
+          </a></div>
+        <ul>
+          <li><a href="<?cs var:toroot ?>guide/components/intents-common.html">
+            <span class="en">Common Intents</span>
+          </a></li>
+        </ul>
+      </li>
       <li><a href="<?cs var:toroot ?>guide/components/processes-and-threads.html">
           <span class="en">Processes and Threads</span>
         </a>
diff --git a/docs/html/guide/topics/connectivity/bluetooth-le.jd b/docs/html/guide/topics/connectivity/bluetooth-le.jd
index 21950c2..449c892 100644
--- a/docs/html/guide/topics/connectivity/bluetooth-le.jd
+++ b/docs/html/guide/topics/connectivity/bluetooth-le.jd
@@ -44,6 +44,15 @@
 </div>
 </div>
 
+<a class="notice-developers-video" href="http://www.youtube.com/watch?v=vUbFB1Qypg8">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Bluetooth Low Energy API</p>
+</div>
+</a>
+
+
+
 
 <p>
 Android 4.3 (API Level 18) introduces built-in platform support for Bluetooth Low
diff --git a/docs/html/guide/topics/manifest/category-element.jd b/docs/html/guide/topics/manifest/category-element.jd
index 41a2cfded..a4b93ee 100644
--- a/docs/html/guide/topics/manifest/category-element.jd
+++ b/docs/html/guide/topics/manifest/category-element.jd
@@ -27,6 +27,14 @@
 the string value for {@code CATEGORY_LAUNCHER} is 
 "{@code android.intent.category.LAUNCHER}".
 
+<p class="note"><strong>Note:</strong> In order to receive implicit intents, you must include the
+{@link android.content.Intent#CATEGORY_DEFAULT} category in the intent filter. The methods
+{@link android.app.Activity#startActivity startActivity()} and
+{@link android.app.Activity#startActivityForResult startActivityForResult()} treat all intents
+as if they declared the {@link android.content.Intent#CATEGORY_DEFAULT} category.
+If you do not declare it in your intent filter, no implicit intents will resolve to
+your activity.</p>
+
 <p>
 Custom categories should use the package name as a prefix, to ensure
 that they are unique.
diff --git a/docs/html/guide/topics/manifest/data-element.jd b/docs/html/guide/topics/manifest/data-element.jd
index 766d2d7..27950d0 100644
--- a/docs/html/guide/topics/manifest/data-element.jd
+++ b/docs/html/guide/topics/manifest/data-element.jd
@@ -5,34 +5,35 @@
 
 <dl class="xml">
 <dt>syntax:</dt>
-<dd><pre class="stx">&lt;data android:<a href="#host">host</a>="<i>string</i>"
-      android:<a href="#mime">mimeType</a>="<i>string</i>"
+<dd><pre class="stx">&lt;data android:<a href="#scheme">scheme</a>="<i>string</i>"
+      android:<a href="#host">host</a>="<i>string</i>"
+      android:<a href="#port">port</a>="<i>string</i>"
       android:<a href="#path">path</a>="<i>string</i>"
       android:<a href="#path">pathPattern</a>="<i>string</i>"
       android:<a href="#path">pathPrefix</a>="<i>string</i>"
-      android:<a href="#port">port</a>="<i>string</i>"
-      android:<a href="#scheme">scheme</a>="<i>string</i>" /&gt;</pre></dd>
+      android:<a href="#mime">mimeType</a>="<i>string</i>" /&gt;</pre></dd>
 
 
 <dt>contained in:</dt>
 <dd><code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code></dd>
 
 <dt>description:</dt>
-<dd>Adds a data specification to an intent filter.  The specification can 
-be just a data type (the <code><a href="{@docRoot}guide/topics/manifest/data-element.html#mime">mimeType</a></code> attribute), 
-just a URI, or both a data type and a URI.  A URI is specified by separate 
+<dd>Adds a data specification to an intent filter.  The specification can
+be just a data type (the <code><a href="{@docRoot}guide/topics/manifest/data-element.html#mime">mimeType</a></code> attribute),
+just a URI, or both a data type and a URI.  A URI is specified by separate
 attributes for each of its parts:
 
-<p style="margin-left: 2em">{@code scheme://host:port/path} <i>or</i> 
-{@code pathPrefix} <i>or</i> {@code pathPattern}</p>
+<p style="margin-left: 2em">
+{@code &lt;scheme>://&lt;host>:&lt;port>/[&lt;path>|&lt;pathPrefix>|&lt;pathPattern>]}</p>
 
 <p>
-These attributes are optional, but also mutually dependent: 
-If a <code><a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">scheme</a></code> is not specified for the 
-intent filter, all the other URI attributes are ignored.  If a 
-<code><a href="{@docRoot}guide/topics/manifest/data-element.html#host">host</a></code> is not specified for the filter, 
-the {@code port} attribute and all the path attributes are ignored.
-</p>
+These attributes that specify the URL format are optional, but also mutually dependent:
+<ul>
+  <li>If a <code><a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">scheme</a></code>
+is not specified for the intent filter, all the other URI attributes are ignored.</li>
+  <li>If a <code><a href="{@docRoot}guide/topics/manifest/data-element.html#host">host</a></code>
+is not specified for the filter, the {@code port} attribute and all the path attributes are ignored.
+</ul>
 
 <p>
 All the {@code &lt;data&gt;} elements contained within the same
@@ -54,93 +55,26 @@
 &lt;/intent-filter&gt;</pre>
 
 <p>
-You can place any number of &lt;data&gt; elements inside an
-<code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> to give it multiple data 
-options.  None of its attributes have default values.  
+You can place any number of {@code &lt;data&gt;} elements inside an
+<code><a href="{@docRoot}guide/topics/manifest/intent-filter-element.html">&lt;intent-filter&gt;</a></code> to give it multiple data
+options.  None of its attributes have default values.
 </p>
 
 <p>
 Information on how intent filters work, including the rules for how Intent objects
 are matched against filters, can be found in another document,
 <a href="{@docRoot}guide/components/intents-filters.html">Intents and
-Intent Filters</a>.  See also the 
-<a href="{@docRoot}guide/topics/manifest/manifest-intro.html#ifs">Intent Filters</a> 
-section in the introduction.
+Intent Filters</a>.  See also the
+<a href="{@docRoot}guide/topics/manifest/manifest-intro.html#ifs">Intent Filters</a>
+section in the manifest file overview.
 </p></dd>
 
 <dt>attributes:</dt>
 <dd><dl class="attr">
-<dt><a name="host"></a>{@code android:host}</dt>
-<dd>The host part of a URI authority.  This attribute is meaningless
-unless a <code><a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">scheme</a></code> attribute is also 
-specified for the filter.
-
-<p class="note">Note: host name matching in the Android framework is
-case-sensitive, unlike the formal RFC.  As a result, you should always specify
-host names using lowercase letters.</p>
-</dd>
-
-<dt><a name="mime"></a>{@code android:mimeType}</dt>
-<dd>A MIME media type, such as {@code image/jpeg} or {@code audio/mpeg4-generic}.  
-The subtype can be the asterisk wildcard ({@code *}) to indicate that any 
-subtype matches.
-
-<p>It's common for an intent filter to declare a {@code &lt;data>} that includes
-only the {@code android:mimeType} attribute.</p>
-
-<p class="note">Note: MIME type matching in the Android framework is
-case-sensitive, unlike formal RFC MIME types.  As a result, you should always
-specify MIME types using lowercase letters.</p>
-</dd>
-
-<dt><a name="path"></a>{@code android:path}
-<br/>{@code android:pathPrefix}
-<br/>{@code android:pathPattern}</dt>
-<dd>The path part of a URI.  The {@code path} attribute specifies a complete 
-path that is matched against the complete path in an Intent object.  The 
-{@code pathPrefix} attribute specifies a partial path that is matched against 
-only the initial part of the path in the Intent object.  The {@code pathPattern} 
-attribute specifies a complete path that is matched against the complete path 
-in the Intent object, but it can contain the following wildcards: 
-
-<ul>
-<li>An asterisk ('{@code *}') matches a sequence of 0 to many occurrences of
-the immediately preceding character.</li>
-
-<li>A period followed by an asterisk ("{@code .*}") matches any sequence of 
-0 to many characters.</li>
-</ul>
-
-<p>
-Because '{@code \}' is used as an escape character when the string is read 
-from XML (before it is parsed as a pattern), you will need to double-escape:  
-For example, a literal '{@code *}' would be written as "{@code \\*}" and a 
-literal '{@code \}' would be written as "{@code \\\\}".  This is basically 
-the same as what you would need to write if constructing the string in Java code.
-</p>
-
-<p>
-For more information on these three types of patterns, see the descriptions of 
-{@link android.os.PatternMatcher#PATTERN_LITERAL},
-{@link android.os.PatternMatcher#PATTERN_PREFIX}, and
-{@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB} in the
-{@link android.os.PatternMatcher} class.
-</p>
-
-<p>These attributes are meaningful only if the 
-<code><a href="#scheme">scheme</a></code> and <code><a href="#host">host</a></code> 
-attributes are also specified for the filter.
-</p></dd>
-
-<dt><a name="port"></a>{@code android:port}</dt>
-<dd>The port part of a URI authority.  This attribute is meaningful only 
-if the <code><a href="#scheme">scheme</a></code> and 
-<code><a href="#host">host</a></code> attributes are also specified for 
-the filter.</dd>
 
 <dt><a name="scheme"></a>{@code android:scheme}</dt>
-<dd>The scheme part of a URI.  This is the minimal essential attribute for 
-specifying a URI; at least one {@code scheme} attribute must be set 
+<dd>The scheme part of a URI.  This is the minimal essential attribute for
+specifying a URI; at least one {@code scheme} attribute must be set
 for the filter, or none of the other URI attributes are meaningful.
 
 <p>
@@ -149,16 +83,89 @@
 </p>
 
 <p>
-If the filter has a data type set (the <code><a href="{@docRoot}guide/topics/manifest/data-element.html#mime">mimeType</a></code> 
+If the filter has a data type set (the <code><a
+href="{@docRoot}guide/topics/manifest/data-element.html#mime">mimeType</a></code>
 attribute) but no scheme, the {@code content:} and {@code file:} schemes are
 assumed.
 </p>
 
-<p class="note">Note: scheme matching in the Android framework is
+<p class="note"><strong>Note</strong>: Scheme matching in the Android framework is
 case-sensitive, unlike the RFC.  As a result, you should always specify schemes
 using lowercase letters.</p>
 </dd>
-</dl></dd>  
+
+<dt><a name="host"></a>{@code android:host}</dt>
+<dd>The host part of a URI authority.  This attribute is meaningless
+unless a <code><a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">scheme</a></code> attribute is also
+specified for the filter.
+
+<p class="note"><strong>Note</strong>: host name matching in the Android framework is
+case-sensitive, unlike the formal RFC.  As a result, you should always specify
+host names using lowercase letters.</p>
+</dd>
+
+
+<dt><a name="port"></a>{@code android:port}</dt>
+<dd>The port part of a URI authority.  This attribute is meaningful only
+if the <code><a href="#scheme">scheme</a></code> and
+<code><a href="#host">host</a></code> attributes are also specified for
+the filter.</dd>
+
+
+<dt><a name="path"></a>{@code android:path}
+<br/>{@code android:pathPrefix}
+<br/>{@code android:pathPattern}</dt>
+<dd>The path part of a URI.  The {@code path} attribute specifies a complete
+path that is matched against the complete path in an Intent object.  The
+{@code pathPrefix} attribute specifies a partial path that is matched against
+only the initial part of the path in the Intent object.  The {@code pathPattern}
+attribute specifies a complete path that is matched against the complete path
+in the Intent object, but it can contain the following wildcards:
+
+<ul>
+<li>An asterisk ('{@code *}') matches a sequence of 0 to many occurrences of
+the immediately preceding character.</li>
+
+<li>A period followed by an asterisk ("{@code .*}") matches any sequence of
+0 to many characters.</li>
+</ul>
+
+<p>
+Because '{@code \}' is used as an escape character when the string is read
+from XML (before it is parsed as a pattern), you will need to double-escape:
+For example, a literal '{@code *}' would be written as "{@code \\*}" and a
+literal '{@code \}' would be written as "{@code \\\\}".  This is basically
+the same as what you would need to write if constructing the string in Java code.
+</p>
+
+<p>
+For more information on these three types of patterns, see the descriptions of
+{@link android.os.PatternMatcher#PATTERN_LITERAL},
+{@link android.os.PatternMatcher#PATTERN_PREFIX}, and
+{@link android.os.PatternMatcher#PATTERN_SIMPLE_GLOB} in the
+{@link android.os.PatternMatcher} class.
+</p>
+
+<p>These attributes are meaningful only if the
+<code><a href="#scheme">scheme</a></code> and <code><a href="#host">host</a></code>
+attributes are also specified for the filter.
+</p></dd>
+
+<dt><a name="mime"></a>{@code android:mimeType}</dt>
+<dd>A MIME media type, such as {@code image/jpeg} or {@code audio/mpeg4-generic}.
+The subtype can be the asterisk wildcard ({@code *}) to indicate that any
+subtype matches.
+
+<p>It's common for an intent filter to declare a {@code &lt;data>} that includes
+only the {@code android:mimeType} attribute.</p>
+
+
+<p class="note"><strong>Note</strong>: MIME type matching in the Android framework is
+case-sensitive, unlike formal RFC MIME types.  As a result, you should always
+specify MIME types using lowercase letters.</p>
+</dd>
+
+</dl></dd>
 
 <!-- ##api level indication## -->
 <dt>introduced in:</dt>
diff --git a/docs/html/guide/topics/manifest/uses-sdk-element.jd b/docs/html/guide/topics/manifest/uses-sdk-element.jd
index 9169658..8de4739 100644
--- a/docs/html/guide/topics/manifest/uses-sdk-element.jd
+++ b/docs/html/guide/topics/manifest/uses-sdk-element.jd
@@ -273,55 +273,55 @@
     <td>{@link android.os.Build.VERSION_CODES#HONEYCOMB_MR1}</td>
     <td><a href="{@docRoot}about/versions/android-3.1-highlights.html">Platform Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-3.0.html">Android 3.0.x</td>
+  <tr><td><a href="{@docRoot}about/versions/android-3.0.html">Android 3.0.x</a></td>
     <td><a href="{@docRoot}sdk/api_diff/11/changes.html" title="Diff Report">11</a></td>
     <td>{@link android.os.Build.VERSION_CODES#HONEYCOMB}</td>
     <td><a href="{@docRoot}about/versions/android-3.0-highlights.html">Platform Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.3.3.html">Android 2.3.4<br>Android 2.3.3</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.3.3.html">Android 2.3.4<br>Android 2.3.3</a></td>
     <td><a href="{@docRoot}sdk/api_diff/10/changes.html" title="Diff Report">10</a></td>
     <td>{@link android.os.Build.VERSION_CODES#GINGERBREAD_MR1}</td>
     <td rowspan="2"><a href="{@docRoot}about/versions/android-2.3-highlights.html">Platform
 Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.3.html">Android 2.3.2<br>Android 2.3.1<br>Android
-2.3</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.3.html">Android 2.3.2<br>Android 2.3.1<br>
+  Android 2.3</a></td>
     <td><a href="{@docRoot}sdk/api_diff/9/changes.html" title="Diff Report">9</a></td>
     <td>{@link android.os.Build.VERSION_CODES#GINGERBREAD}</td>
     </tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.2.html">Android 2.2.x</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.2.html">Android 2.2.x</a></td>
     <td ><a href="{@docRoot}sdk/api_diff/8/changes.html" title="Diff Report">8</a></td>
     <td>{@link android.os.Build.VERSION_CODES#FROYO}</td>
     <td><a href="{@docRoot}about/versions/android-2.2-highlights.html">Platform Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.1.html">Android 2.1.x</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.1.html">Android 2.1.x</a></td>
     <td><a href="{@docRoot}sdk/api_diff/7/changes.html" title="Diff Report">7</a></td>
     <td>{@link android.os.Build.VERSION_CODES#ECLAIR_MR1}</td>
     <td rowspan="3" ><a href="{@docRoot}about/versions/android-2.0-highlights.html">Platform
 Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.0.1.html">Android 2.0.1</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.0.1.html">Android 2.0.1</a></td>
     <td><a href="{@docRoot}sdk/api_diff/6/changes.html" title="Diff Report">6</a></td>
     <td>{@link android.os.Build.VERSION_CODES#ECLAIR_0_1}</td>
     </tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-2.0.html">Android 2.0</td>
+  <tr><td><a href="{@docRoot}about/versions/android-2.0.html">Android 2.0</a></td>
     <td><a href="{@docRoot}sdk/api_diff/5/changes.html" title="Diff Report">5</a></td>
     <td>{@link android.os.Build.VERSION_CODES#ECLAIR}</td>
     </tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-1.6.html">Android 1.6</td>
+  <tr><td><a href="{@docRoot}about/versions/android-1.6.html">Android 1.6</a></td>
     <td><a href="{@docRoot}sdk/api_diff/4/changes.html" title="Diff Report">4</a></td>
     <td>{@link android.os.Build.VERSION_CODES#DONUT}</td>
     <td><a href="{@docRoot}about/versions/android-1.6-highlights.html">Platform Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-1.5.html">Android 1.5</td>
+  <tr><td><a href="{@docRoot}about/versions/android-1.5.html">Android 1.5</a></td>
     <td><a href="{@docRoot}sdk/api_diff/3/changes.html" title="Diff Report">3</a></td>
     <td>{@link android.os.Build.VERSION_CODES#CUPCAKE}</td>
     <td><a href="{@docRoot}about/versions/android-1.5-highlights.html">Platform Highlights</a></td></tr>
 
-  <tr><td><a href="{@docRoot}about/versions/android-1.1.html">Android 1.1</td>
+  <tr><td><a href="{@docRoot}about/versions/android-1.1.html">Android 1.1</a></td>
     <td>2</td>
     <td>{@link android.os.Build.VERSION_CODES#BASE_1_1}</td><td></td></tr>
 
diff --git a/docs/html/guide/topics/providers/document-provider.jd b/docs/html/guide/topics/providers/document-provider.jd
index 9af8d5ae..8ea08bd 100644
--- a/docs/html/guide/topics/providers/document-provider.jd
+++ b/docs/html/guide/topics/providers/document-provider.jd
@@ -3,8 +3,11 @@
 <div id="qv-wrapper">
 <div id="qv">
 
-<h2>In this document</h2>
-<ol>
+<h2>In this document
+ <a href="#" onclick="hideNestedItems('#toc44',this);return false;" class="header-toggle">
+        <span class="more">show more</span>
+        <span class="less" style="display:none">show less</span></a></h2>
+<ol id="toc44" class="hide-nested">
     <li>
         <a href="#overview">Overview</a>
     </li>
@@ -38,8 +41,25 @@
 <ol>
     <li>{@link android.provider.DocumentsProvider}</li>
     <li>{@link android.provider.DocumentsContract}</li>
-    <li>{@link android.provider.DocumentsContract.Document}</li>
-    <li>{@link android.provider.DocumentsContract.Root}</li>
+</ol>
+
+<h2>Videos</h2>
+
+<ol>
+    <li><a href="http://www.youtube.com/watch?v=zxHVeXbK1P4">
+DevBytes: Android 4.4 Storage Access Framework: Provider</a></li>
+     <li><a href="http://www.youtube.com/watch?v=UFj9AEz0DHQ">
+DevBytes: Android 4.4 Storage Access Framework: Client</a></li>
+</ol>
+
+
+<h2>Code Samples</h2>
+
+<ol>
+    <li><a href="{@docRoot}samples/StorageProvider/index.html">
+Storage Provider</a></li>
+     <li><a href="{@docRoot}samples/StorageClient/index.html">
+StorageClient</a></li>
 </ol>
 
 <h2>See Also</h2>
@@ -50,18 +70,28 @@
         </a>
     </li>
 </ol>
+
 </div>
 </div>
-<p>Android 4.4 (API level 19) introduces the Storage Access Framework. The
-Storage Access Framework encapsulates capabilities in the Android platform that
-allow apps to request files from file storage services. The Storage Access
-Framework includes the following:</p>
+
+
+<p>Android 4.4 (API level 19) introduces the Storage Access Framework (SAF). The SAF
+ makes it simple for users to browse and open documents, images, and other files
+across all of their their preferred document storage providers. A standard, easy-to-use UI
+lets users browse files and access recents in a consistent way across apps and providers.</p>
+
+<p>Cloud or local storage services can participate in this ecosystem by implementing a
+{@link android.provider.DocumentsProvider} that encapsulates their services. Client
+apps that need access to a provider's documents can integrate with the SAF with just a few
+lines of code.</p>
+
+<p>The SAF includes the following:</p>
 
 <ul>
 <li><strong>Document provider</strong>&mdash;A content provider that allows a
-storage service (such as Google Drive) to reveal the files it manages. This is
+storage service (such as Google Drive) to reveal the files it manages. A document provider is
 implemented as a subclass of the {@link android.provider.DocumentsProvider} class.
-The document provider schema is based on a traditional file hierarchy,
+The document-provider schema is based on a traditional file hierarchy,
 though how your document provider physically stores data is up to you.
 The Android platform includes several built-in document providers, such as
 Downloads, Images, and Videos.</li>
@@ -75,7 +105,7 @@
 document providers that satisfy the client app's search criteria.</li>
 </ul>
 
-<p>Some of the features offered by the Storage Access Framework are as follows:</p>
+<p>Some of the features offered by the SAF are as follows:</p>
 <ul>
 <li>Lets users browse content from all document providers, not just a single app.</li>
 <li>Makes it possible for your app to have long term, persistent access to
@@ -87,7 +117,7 @@
 
 <h2 id ="overview">Overview</h2>
 
-<p>The Storage Access Framework centers around a content provider that is a
+<p>The SAF centers around a content provider that is a
 subclass of the {@link android.provider.DocumentsProvider} class. Within a <em>document provider</em>, data is
 structured as a traditional file hierarchy:</p>
 <p><img src="{@docRoot}images/providers/storage_datamodel.png" alt="data model" /></p>
@@ -134,7 +164,7 @@
 long as it can be accessed through the {@link android.provider.DocumentsProvider} API. For example, you
 could use tag-based cloud storage for your data.</p>
 
-<p>Figure 2 shows an example of how a photo app might use the Storage Access Framework
+<p>Figure 2 shows an example of how a photo app might use the SAF
 to access  stored data:</p>
 <p><img src="{@docRoot}images/providers/storage_dataflow.png" alt="app" /></p>
 
@@ -143,7 +173,7 @@
 <p>Note the following:</p>
 <ul>
 
-<li>In the Storage Access Framework, providers and clients don't interact
+<li>In the SAF, providers and clients don't interact
 directly. A client requests permission to interact
 with files (that is, to read, edit, create, or delete files).</li>
 
@@ -430,7 +460,7 @@
 
 <h3 id="edit">Edit a document</h3>
 
-<p>You can use the Storage Access Framework to edit a text document in place.
+<p>You can use the SAF to edit a text document in place.
 This snippet fires
 the {@link android.content.Intent#ACTION_OPEN_DOCUMENT} intent and uses the
 category {@link android.content.Intent#CATEGORY_OPENABLE} to to display only
@@ -513,8 +543,8 @@
 
 <p>
 If you're developing an app that provides storage services for files (such as
-a cloud save service), you can make your files available through the Storage
-Access Framework by writing a custom document provider.  This section describes
+a cloud save service), you can make your files available through the
+SAF by writing a custom document provider.  This section describes
 how to do this.</p>
 
 
@@ -540,13 +570,25 @@
 You must export your provider so that other apps can see it.</li>
 
 <li>The attribute <code>android:grantUriPermissions</code> set to
-<code>&quot;true&quot;</code>. This allows the system to grant other apps access
+<code>&quot;true&quot;</code>. This setting allows the system to grant other apps access
 to content in your provider. For a discussion of how to persist a grant for
 a particular document, see <a href="#permissions">Persist permissions</a>.</li>
 
 <li>The {@code MANAGE_DOCUMENTS} permission. By default a provider is available
-to everyone. Adding this permission restricts your provider to the system,
-which is important for security. </li>
+to everyone. Adding this permission restricts your provider to the system.
+This restriction is important for security.</li>
+
+<li>The {@code android:enabled} attribute set to a boolean value defined in a resource
+file. The purpose of this attribute is to disable the provider on devices running Android 4.3 or lower.
+For example, {@code android:enabled=&quot;&#64;bool/atLeastKitKat&quot;}. In
+addition to including this attribute in the manifest, you need to do the following:
+<ul>
+<li>In your {@code bool.xml} resources file under {@code res/values/}, add
+this line: <pre>&lt;bool name=&quot;atLeastKitKat&quot;&gt;false&lt;/bool&gt;</pre></li>
+
+<li>In your {@code bool.xml} resources file under {@code res/values-v19/}, add
+this line: <pre>&lt;bool name=&quot;atLeastKitKat&quot;&gt;true&lt;/bool&gt;</pre></li>
+</ul></li>
 
 <li>An intent filter that includes the
 {@code android.content.action.DOCUMENTS_PROVIDER} action, so that your provider
@@ -566,7 +608,8 @@
             android:authorities=&quot;com.example.android.storageprovider.documents&quot;
             android:grantUriPermissions=&quot;true&quot;
             android:exported=&quot;true&quot;
-            android:permission=&quot;android.permission.MANAGE_DOCUMENTS&quot;&gt;
+            android:permission=&quot;android.permission.MANAGE_DOCUMENTS&quot;
+            android:enabled=&quot;&#64;bool/atLeastKitKat&quot;&gt;
             &lt;intent-filter&gt;
                 &lt;action android:name=&quot;android.content.action.DOCUMENTS_PROVIDER&quot; /&gt;
             &lt;/intent-filter&gt;
@@ -575,7 +618,7 @@
 
 &lt;/manifest&gt;</pre>
 
-<h4>Supporting devices running Android 4.3 and lower</h4>
+<h4 id="43">Supporting devices running Android 4.3 and lower</h4>
 
 <p>The
 {@link android.content.Intent#ACTION_OPEN_DOCUMENT} intent is only available
@@ -583,7 +626,7 @@
 If you want your application to support {@link android.content.Intent#ACTION_GET_CONTENT}
 to accommodate devices that are running Android 4.3 and lower, you should
 disable the {@link android.content.Intent#ACTION_GET_CONTENT} intent filter in
-your manifest if a device is running Android 4.4 or higher. A
+your manifest for devices running Android 4.4 or higher. A
 document provider and {@link android.content.Intent#ACTION_GET_CONTENT} should be considered
  mutually exclusive. If you support both of them simultaneously, your app will
 appear twice in the system picker UI, offering two different ways of accessing
@@ -630,7 +673,7 @@
 <a href="{@docRoot}guide/topics/providers/content-provider-creating.html#ContractClass">
 Content Providers</a> developers guide. A contract class is a {@code public final} class
 that contains constant definitions for the URIs, column names, MIME types, and
-other metadata that pertain to the provider. The Storage Access Framework
+other metadata that pertain to the provider. The SAF
 provides these contract classes for you, so you don't need to write your
 own:</p>
 
@@ -872,4 +915,4 @@
     getContentResolver().notifyChange(DocumentsContract
             .buildRootsUri(AUTHORITY), null);
 }
-</pre>
+</pre>
\ No newline at end of file
diff --git a/docs/html/images/community/aco1small.png b/docs/html/images/community/aco1small.png
new file mode 100644
index 0000000..ce4cb66
--- /dev/null
+++ b/docs/html/images/community/aco1small.png
Binary files differ
diff --git a/docs/html/images/community/hackathon-gdgaug.jpg b/docs/html/images/community/hackathon-gdgaug.jpg
new file mode 100644
index 0000000..8c939c5
--- /dev/null
+++ b/docs/html/images/community/hackathon-gdgaug.jpg
Binary files differ
diff --git a/docs/html/images/community/kk-hero.jpg b/docs/html/images/community/kk-hero.jpg
new file mode 100644
index 0000000..713c861
--- /dev/null
+++ b/docs/html/images/community/kk-hero.jpg
Binary files differ
diff --git a/docs/html/images/community/kk-hero2.jpg b/docs/html/images/community/kk-hero2.jpg
new file mode 100644
index 0000000..c404116
--- /dev/null
+++ b/docs/html/images/community/kk-hero2.jpg
Binary files differ
diff --git a/docs/html/images/components/intent-filters@2x.png b/docs/html/images/components/intent-filters@2x.png
new file mode 100644
index 0000000..5b1e38b
--- /dev/null
+++ b/docs/html/images/components/intent-filters@2x.png
Binary files differ
diff --git a/docs/html/images/kk-devices.png b/docs/html/images/kk-devices.png
new file mode 100644
index 0000000..3c7bbf1
--- /dev/null
+++ b/docs/html/images/kk-devices.png
Binary files differ
diff --git a/docs/html/images/systrace/systrace-button.png b/docs/html/images/systrace/systrace-button.png
new file mode 100644
index 0000000..7d93ad0
--- /dev/null
+++ b/docs/html/images/systrace/systrace-button.png
Binary files differ
diff --git a/docs/html/index.jd b/docs/html/index.jd
index 3e59068..191e0fb 100644
--- a/docs/html/index.jd
+++ b/docs/html/index.jd
@@ -1,6 +1,7 @@
 fullpage=true
 no_footer_links=true
 carousel=true
+excludeFromSuggestions=true
 page.metaDescription=The official site for Android developers. Provides the Android SDK and documentation for app developers and designers.
 page.customHeadTag=<meta name="google-site-verification" content="sa-bIAI6GKvct3f61-WpRguHq-aNjtF7xJjMTSi79as" />
 
diff --git a/docs/html/license.jd b/docs/html/license.jd
index 20e68fa..b98c912 100644
--- a/docs/html/license.jd
+++ b/docs/html/license.jd
@@ -1,5 +1,6 @@
 page.title=Content License
 fullpage=1
+excludeFromSuggestions=true
 @jd:body
 
 <div class="wrap" style="width:940px;">
diff --git a/docs/html/offline.jd b/docs/html/offline.jd
index 73da779..6d4483f 100644
--- a/docs/html/offline.jd
+++ b/docs/html/offline.jd
@@ -1,5 +1,6 @@
 home=true
 page.title=Welcome
+excludeFromSuggestions=true
 @jd:body
 
 <style type="text/css">
diff --git a/docs/html/reference/com/google/android/gms/R.attr.html b/docs/html/reference/com/google/android/gms/R.attr.html
index 1e4794f..d1de6ff 100644
--- a/docs/html/reference/com/google/android/gms/R.attr.html
+++ b/docs/html/reference/com/google/android/gms/R.attr.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.color.html b/docs/html/reference/com/google/android/gms/R.color.html
index e18f487..47bba85 100644
--- a/docs/html/reference/com/google/android/gms/R.color.html
+++ b/docs/html/reference/com/google/android/gms/R.color.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.drawable.html b/docs/html/reference/com/google/android/gms/R.drawable.html
index 3946968..deb40c2 100644
--- a/docs/html/reference/com/google/android/gms/R.drawable.html
+++ b/docs/html/reference/com/google/android/gms/R.drawable.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.html b/docs/html/reference/com/google/android/gms/R.html
index e731b8e..4eec6ae 100644
--- a/docs/html/reference/com/google/android/gms/R.html
+++ b/docs/html/reference/com/google/android/gms/R.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.id.html b/docs/html/reference/com/google/android/gms/R.id.html
index dc59f21..f5c0a9a 100644
--- a/docs/html/reference/com/google/android/gms/R.id.html
+++ b/docs/html/reference/com/google/android/gms/R.id.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.integer.html b/docs/html/reference/com/google/android/gms/R.integer.html
index 1c72378..ff5338d 100644
--- a/docs/html/reference/com/google/android/gms/R.integer.html
+++ b/docs/html/reference/com/google/android/gms/R.integer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.string.html b/docs/html/reference/com/google/android/gms/R.string.html
index cf92f5c..ee2e867 100644
--- a/docs/html/reference/com/google/android/gms/R.string.html
+++ b/docs/html/reference/com/google/android/gms/R.string.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/R.styleable.html b/docs/html/reference/com/google/android/gms/R.styleable.html
index 7f37faf..a151380 100644
--- a/docs/html/reference/com/google/android/gms/R.styleable.html
+++ b/docs/html/reference/com/google/android/gms/R.styleable.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/AdListener.html b/docs/html/reference/com/google/android/gms/ads/AdListener.html
index 5665c54..321230f 100644
--- a/docs/html/reference/com/google/android/gms/ads/AdListener.html
+++ b/docs/html/reference/com/google/android/gms/ads/AdListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/AdRequest.Builder.html b/docs/html/reference/com/google/android/gms/ads/AdRequest.Builder.html
index 2a3d395..f1088d0 100644
--- a/docs/html/reference/com/google/android/gms/ads/AdRequest.Builder.html
+++ b/docs/html/reference/com/google/android/gms/ads/AdRequest.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/AdRequest.html b/docs/html/reference/com/google/android/gms/ads/AdRequest.html
index d5d9738..951173a 100644
--- a/docs/html/reference/com/google/android/gms/ads/AdRequest.html
+++ b/docs/html/reference/com/google/android/gms/ads/AdRequest.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/AdSize.html b/docs/html/reference/com/google/android/gms/ads/AdSize.html
index 6724572d..81b7ae4 100644
--- a/docs/html/reference/com/google/android/gms/ads/AdSize.html
+++ b/docs/html/reference/com/google/android/gms/ads/AdSize.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/AdView.html b/docs/html/reference/com/google/android/gms/ads/AdView.html
index cc1f550..85ec19d 100644
--- a/docs/html/reference/com/google/android/gms/ads/AdView.html
+++ b/docs/html/reference/com/google/android/gms/ads/AdView.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/InterstitialAd.html b/docs/html/reference/com/google/android/gms/ads/InterstitialAd.html
index c1c3fe0..5c7b0c9 100644
--- a/docs/html/reference/com/google/android/gms/ads/InterstitialAd.html
+++ b/docs/html/reference/com/google/android/gms/ads/InterstitialAd.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.Info.html b/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.Info.html
index e8d832d..c4bb33e 100644
--- a/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.Info.html
+++ b/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.Info.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html b/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html
index b1d6731..11ca36f 100644
--- a/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html
+++ b/docs/html/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
@@ -752,7 +763,7 @@
  <p>
  It is intended that the advertising ID completely replace existing usage of other
  identifiers for ads purposes (such as use of <code>ANDROID_ID</code> in
- <code><a href="/">ERROR(/Settings.Secure)</a></code>) when Google Play Services is available. Cases where
+ <code><a href="/reference/android/provider/Settings.Secure.html">Settings.Secure</a></code>) when Google Play Services is available. Cases where
  Google Play Services is unavailable are indicated by a
  <code><a href="/reference/com/google/android/gms/common/GooglePlayServicesNotAvailableException.html">GooglePlayServicesNotAvailableException</a></code> being thrown by getAdvertisingIdInfo().
 </p>
@@ -1204,7 +1215,7 @@
       <table class="jd-tagtable">
         <tr>
           <th>context</td>
-          <td>Current <code><a href="/reference/android/content/Context.html">Context</a></code> (such as the current <code><a href="/">ERROR(/Activity)</a></code>).</td>
+          <td>Current <code><a href="/reference/android/content/Context.html">Context</a></code> (such as the current <code><a href="/reference/android/app/Activity.html">Activity</a></code>).</td>
         </tr>
       </table>
   </div>
diff --git a/docs/html/reference/com/google/android/gms/ads/identifier/package-summary.html b/docs/html/reference/com/google/android/gms/ads/identifier/package-summary.html
index 59f719a..f20721a 100644
--- a/docs/html/reference/com/google/android/gms/ads/identifier/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/ads/identifier/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/NetworkExtras.html b/docs/html/reference/com/google/android/gms/ads/mediation/NetworkExtras.html
index c82c4f6..baf2486 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/NetworkExtras.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/NetworkExtras.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/admob/AdMobExtras.html b/docs/html/reference/com/google/android/gms/ads/mediation/admob/AdMobExtras.html
index 6d1aa4a..1befa17 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/admob/AdMobExtras.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/admob/AdMobExtras.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/admob/package-summary.html b/docs/html/reference/com/google/android/gms/ads/mediation/admob/package-summary.html
index 7117324..d1333de 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/admob/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/admob/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/customevent/CustomEventExtras.html b/docs/html/reference/com/google/android/gms/ads/mediation/customevent/CustomEventExtras.html
index 3d4c0f3..d2db70e 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/customevent/CustomEventExtras.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/customevent/CustomEventExtras.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/customevent/package-summary.html b/docs/html/reference/com/google/android/gms/ads/mediation/customevent/package-summary.html
index b2e831e..14f321f 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/customevent/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/customevent/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/mediation/package-summary.html b/docs/html/reference/com/google/android/gms/ads/mediation/package-summary.html
index c6ca1d6..635eff2 100644
--- a/docs/html/reference/com/google/android/gms/ads/mediation/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/ads/mediation/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/ads/package-summary.html b/docs/html/reference/com/google/android/gms/ads/package-summary.html
index 8c96a79..ea28ff1 100644
--- a/docs/html/reference/com/google/android/gms/ads/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/ads/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/AppState.html b/docs/html/reference/com/google/android/gms/appstate/AppState.html
index bc61b35..356d960 100644
--- a/docs/html/reference/com/google/android/gms/appstate/AppState.html
+++ b/docs/html/reference/com/google/android/gms/appstate/AppState.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/AppStateBuffer.html b/docs/html/reference/com/google/android/gms/appstate/AppStateBuffer.html
index e4e34a6..9b62726 100644
--- a/docs/html/reference/com/google/android/gms/appstate/AppStateBuffer.html
+++ b/docs/html/reference/com/google/android/gms/appstate/AppStateBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/AppStateClient.Builder.html b/docs/html/reference/com/google/android/gms/appstate/AppStateClient.Builder.html
index ab28269..abf8e78 100644
--- a/docs/html/reference/com/google/android/gms/appstate/AppStateClient.Builder.html
+++ b/docs/html/reference/com/google/android/gms/appstate/AppStateClient.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/AppStateClient.html b/docs/html/reference/com/google/android/gms/appstate/AppStateClient.html
index 2ea169f..d5809a6 100644
--- a/docs/html/reference/com/google/android/gms/appstate/AppStateClient.html
+++ b/docs/html/reference/com/google/android/gms/appstate/AppStateClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/OnSignOutCompleteListener.html b/docs/html/reference/com/google/android/gms/appstate/OnSignOutCompleteListener.html
index 4bd073e..0c32261 100644
--- a/docs/html/reference/com/google/android/gms/appstate/OnSignOutCompleteListener.html
+++ b/docs/html/reference/com/google/android/gms/appstate/OnSignOutCompleteListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/OnStateDeletedListener.html b/docs/html/reference/com/google/android/gms/appstate/OnStateDeletedListener.html
index b145688..70a762e 100644
--- a/docs/html/reference/com/google/android/gms/appstate/OnStateDeletedListener.html
+++ b/docs/html/reference/com/google/android/gms/appstate/OnStateDeletedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/OnStateListLoadedListener.html b/docs/html/reference/com/google/android/gms/appstate/OnStateListLoadedListener.html
index 0f2cefb..73da7d9 100644
--- a/docs/html/reference/com/google/android/gms/appstate/OnStateListLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/appstate/OnStateListLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/OnStateLoadedListener.html b/docs/html/reference/com/google/android/gms/appstate/OnStateLoadedListener.html
index e4ce5ed..9442754 100644
--- a/docs/html/reference/com/google/android/gms/appstate/OnStateLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/appstate/OnStateLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/appstate/package-summary.html b/docs/html/reference/com/google/android/gms/appstate/package-summary.html
index da6cd9a..50ef3d7 100644
--- a/docs/html/reference/com/google/android/gms/appstate/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/appstate/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/GoogleAuthException.html b/docs/html/reference/com/google/android/gms/auth/GoogleAuthException.html
index 2d6392e..5de9deb 100644
--- a/docs/html/reference/com/google/android/gms/auth/GoogleAuthException.html
+++ b/docs/html/reference/com/google/android/gms/auth/GoogleAuthException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/GoogleAuthUtil.html b/docs/html/reference/com/google/android/gms/auth/GoogleAuthUtil.html
index 74f6dac..7f74d08 100644
--- a/docs/html/reference/com/google/android/gms/auth/GoogleAuthUtil.html
+++ b/docs/html/reference/com/google/android/gms/auth/GoogleAuthUtil.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/GooglePlayServicesAvailabilityException.html b/docs/html/reference/com/google/android/gms/auth/GooglePlayServicesAvailabilityException.html
index 2600f30..56c3d6c 100644
--- a/docs/html/reference/com/google/android/gms/auth/GooglePlayServicesAvailabilityException.html
+++ b/docs/html/reference/com/google/android/gms/auth/GooglePlayServicesAvailabilityException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/RecoveryDecision.html b/docs/html/reference/com/google/android/gms/auth/RecoveryDecision.html
index 59a1346..f375b27 100644
--- a/docs/html/reference/com/google/android/gms/auth/RecoveryDecision.html
+++ b/docs/html/reference/com/google/android/gms/auth/RecoveryDecision.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/UserRecoverableAuthException.html b/docs/html/reference/com/google/android/gms/auth/UserRecoverableAuthException.html
index 6d39781..efcc752 100644
--- a/docs/html/reference/com/google/android/gms/auth/UserRecoverableAuthException.html
+++ b/docs/html/reference/com/google/android/gms/auth/UserRecoverableAuthException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/UserRecoverableNotifiedException.html b/docs/html/reference/com/google/android/gms/auth/UserRecoverableNotifiedException.html
index 39ae993..3f454ee 100644
--- a/docs/html/reference/com/google/android/gms/auth/UserRecoverableNotifiedException.html
+++ b/docs/html/reference/com/google/android/gms/auth/UserRecoverableNotifiedException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/auth/package-summary.html b/docs/html/reference/com/google/android/gms/auth/package-summary.html
index 4f3165a..62cff8b 100644
--- a/docs/html/reference/com/google/android/gms/auth/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/auth/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/AccountPicker.html b/docs/html/reference/com/google/android/gms/common/AccountPicker.html
index 8697b8f..036b371 100644
--- a/docs/html/reference/com/google/android/gms/common/AccountPicker.html
+++ b/docs/html/reference/com/google/android/gms/common/AccountPicker.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/ConnectionResult.html b/docs/html/reference/com/google/android/gms/common/ConnectionResult.html
index 84d7f54..1412ec2 100644
--- a/docs/html/reference/com/google/android/gms/common/ConnectionResult.html
+++ b/docs/html/reference/com/google/android/gms/common/ConnectionResult.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.ConnectionCallbacks.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.ConnectionCallbacks.html
index 1bc1f05..bb50850 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.ConnectionCallbacks.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.ConnectionCallbacks.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.OnConnectionFailedListener.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.OnConnectionFailedListener.html
index a1f52be..b7b196e 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.OnConnectionFailedListener.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.OnConnectionFailedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.html
index ce3cd96f..3b3c9be 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesNotAvailableException.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesNotAvailableException.html
index d8be4dd..2cd04b9 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesNotAvailableException.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesNotAvailableException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesRepairableException.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesRepairableException.html
index a454fb0..f03309f 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesRepairableException.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesRepairableException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesUtil.html b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesUtil.html
index ca25152..f891479 100644
--- a/docs/html/reference/com/google/android/gms/common/GooglePlayServicesUtil.html
+++ b/docs/html/reference/com/google/android/gms/common/GooglePlayServicesUtil.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
@@ -1315,8 +1326,8 @@
         <span class="jd-tagtitle">Constant Value: </span>
         <span>
             
-                4030000
-                (0x003d7e30)
+                4034000
+                (0x003d8dd0)
             
         </span>
         </div>
diff --git a/docs/html/reference/com/google/android/gms/common/Scopes.html b/docs/html/reference/com/google/android/gms/common/Scopes.html
index 76618ff..98e6ddd 100644
--- a/docs/html/reference/com/google/android/gms/common/Scopes.html
+++ b/docs/html/reference/com/google/android/gms/common/Scopes.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/SignInButton.html b/docs/html/reference/com/google/android/gms/common/SignInButton.html
index efe6661..cc09fff 100644
--- a/docs/html/reference/com/google/android/gms/common/SignInButton.html
+++ b/docs/html/reference/com/google/android/gms/common/SignInButton.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/UserRecoverableException.html b/docs/html/reference/com/google/android/gms/common/UserRecoverableException.html
index 4fbaf32..a6162b7 100644
--- a/docs/html/reference/com/google/android/gms/common/UserRecoverableException.html
+++ b/docs/html/reference/com/google/android/gms/common/UserRecoverableException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/annotation/KeepName.html b/docs/html/reference/com/google/android/gms/common/annotation/KeepName.html
index 7d58ef2..ad44294 100644
--- a/docs/html/reference/com/google/android/gms/common/annotation/KeepName.html
+++ b/docs/html/reference/com/google/android/gms/common/annotation/KeepName.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/data/DataBuffer.html b/docs/html/reference/com/google/android/gms/common/data/DataBuffer.html
index b7c9f29..19f8d2d 100644
--- a/docs/html/reference/com/google/android/gms/common/data/DataBuffer.html
+++ b/docs/html/reference/com/google/android/gms/common/data/DataBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/data/DataBufferUtils.html b/docs/html/reference/com/google/android/gms/common/data/DataBufferUtils.html
index 1317c78..63074f5 100644
--- a/docs/html/reference/com/google/android/gms/common/data/DataBufferUtils.html
+++ b/docs/html/reference/com/google/android/gms/common/data/DataBufferUtils.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/data/Freezable.html b/docs/html/reference/com/google/android/gms/common/data/Freezable.html
index 4b3f9602..5e49bf5 100644
--- a/docs/html/reference/com/google/android/gms/common/data/Freezable.html
+++ b/docs/html/reference/com/google/android/gms/common/data/Freezable.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/data/package-summary.html b/docs/html/reference/com/google/android/gms/common/data/package-summary.html
index 43fec35..479afbb 100644
--- a/docs/html/reference/com/google/android/gms/common/data/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/common/data/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/images/ImageManager.OnImageLoadedListener.html b/docs/html/reference/com/google/android/gms/common/images/ImageManager.OnImageLoadedListener.html
index 237a57c..6c41369 100644
--- a/docs/html/reference/com/google/android/gms/common/images/ImageManager.OnImageLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/common/images/ImageManager.OnImageLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/images/ImageManager.html b/docs/html/reference/com/google/android/gms/common/images/ImageManager.html
index a1613a0..121e38a6 100644
--- a/docs/html/reference/com/google/android/gms/common/images/ImageManager.html
+++ b/docs/html/reference/com/google/android/gms/common/images/ImageManager.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/images/package-summary.html b/docs/html/reference/com/google/android/gms/common/images/package-summary.html
index 4d0498b..091f541 100644
--- a/docs/html/reference/com/google/android/gms/common/images/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/common/images/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/common/package-summary.html b/docs/html/reference/com/google/android/gms/common/package-summary.html
index 851ba14..4cfbc17 100644
--- a/docs/html/reference/com/google/android/gms/common/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/common/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/Game.html b/docs/html/reference/com/google/android/gms/games/Game.html
index c26ce43..b2d3254 100644
--- a/docs/html/reference/com/google/android/gms/games/Game.html
+++ b/docs/html/reference/com/google/android/gms/games/Game.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/GameBuffer.html b/docs/html/reference/com/google/android/gms/games/GameBuffer.html
index dbd040e..3b1582c 100644
--- a/docs/html/reference/com/google/android/gms/games/GameBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/GameBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/GameEntity.html b/docs/html/reference/com/google/android/gms/games/GameEntity.html
index 60d1867..b279344 100644
--- a/docs/html/reference/com/google/android/gms/games/GameEntity.html
+++ b/docs/html/reference/com/google/android/gms/games/GameEntity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/GamesActivityResultCodes.html b/docs/html/reference/com/google/android/gms/games/GamesActivityResultCodes.html
index 1213a32..caec38e 100644
--- a/docs/html/reference/com/google/android/gms/games/GamesActivityResultCodes.html
+++ b/docs/html/reference/com/google/android/gms/games/GamesActivityResultCodes.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/GamesClient.Builder.html b/docs/html/reference/com/google/android/gms/games/GamesClient.Builder.html
index 0de7ffa..28bd52c 100644
--- a/docs/html/reference/com/google/android/gms/games/GamesClient.Builder.html
+++ b/docs/html/reference/com/google/android/gms/games/GamesClient.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/GamesClient.html b/docs/html/reference/com/google/android/gms/games/GamesClient.html
index cb89c93..20f3072 100644
--- a/docs/html/reference/com/google/android/gms/games/GamesClient.html
+++ b/docs/html/reference/com/google/android/gms/games/GamesClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/OnGamesLoadedListener.html b/docs/html/reference/com/google/android/gms/games/OnGamesLoadedListener.html
index d6068df..5152163 100644
--- a/docs/html/reference/com/google/android/gms/games/OnGamesLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/OnGamesLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/OnPlayersLoadedListener.html b/docs/html/reference/com/google/android/gms/games/OnPlayersLoadedListener.html
index 58e3ecb..d4e5e74 100644
--- a/docs/html/reference/com/google/android/gms/games/OnPlayersLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/OnPlayersLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/OnSignOutCompleteListener.html b/docs/html/reference/com/google/android/gms/games/OnSignOutCompleteListener.html
index 0d0248e..a298976 100644
--- a/docs/html/reference/com/google/android/gms/games/OnSignOutCompleteListener.html
+++ b/docs/html/reference/com/google/android/gms/games/OnSignOutCompleteListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/PageDirection.html b/docs/html/reference/com/google/android/gms/games/PageDirection.html
index 844d321..957d6f6 100644
--- a/docs/html/reference/com/google/android/gms/games/PageDirection.html
+++ b/docs/html/reference/com/google/android/gms/games/PageDirection.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/Player.html b/docs/html/reference/com/google/android/gms/games/Player.html
index 6669fcc..a43b86e 100644
--- a/docs/html/reference/com/google/android/gms/games/Player.html
+++ b/docs/html/reference/com/google/android/gms/games/Player.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/PlayerBuffer.html b/docs/html/reference/com/google/android/gms/games/PlayerBuffer.html
index 55b119e..298ebf8 100644
--- a/docs/html/reference/com/google/android/gms/games/PlayerBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/PlayerBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/PlayerEntity.html b/docs/html/reference/com/google/android/gms/games/PlayerEntity.html
index 09f383e..e47f0b7 100644
--- a/docs/html/reference/com/google/android/gms/games/PlayerEntity.html
+++ b/docs/html/reference/com/google/android/gms/games/PlayerEntity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/achievement/Achievement.html b/docs/html/reference/com/google/android/gms/games/achievement/Achievement.html
index be51769..84137c3 100644
--- a/docs/html/reference/com/google/android/gms/games/achievement/Achievement.html
+++ b/docs/html/reference/com/google/android/gms/games/achievement/Achievement.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/achievement/AchievementBuffer.html b/docs/html/reference/com/google/android/gms/games/achievement/AchievementBuffer.html
index 1f3ead1..a793583 100644
--- a/docs/html/reference/com/google/android/gms/games/achievement/AchievementBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/achievement/AchievementBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementUpdatedListener.html b/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementUpdatedListener.html
index c464922..7486dd65 100644
--- a/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementUpdatedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementUpdatedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementsLoadedListener.html b/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementsLoadedListener.html
index 9d38268..e0a7458 100644
--- a/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementsLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/achievement/OnAchievementsLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/achievement/package-summary.html b/docs/html/reference/com/google/android/gms/games/achievement/package-summary.html
index ce00f68..65047e3 100644
--- a/docs/html/reference/com/google/android/gms/games/achievement/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/games/achievement/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/Leaderboard.html b/docs/html/reference/com/google/android/gms/games/leaderboard/Leaderboard.html
index adc0a63..f4c8074 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/Leaderboard.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/Leaderboard.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardBuffer.html b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardBuffer.html
index 37f0760..8316c89 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScore.html b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScore.html
index 71a4266..87a931a 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScore.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScore.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScoreBuffer.html b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScoreBuffer.html
index f480d76..62b58d8 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScoreBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardScoreBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardVariant.html b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardVariant.html
index 468e5dc..853a92f 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardVariant.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/LeaderboardVariant.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardMetadataLoadedListener.html b/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardMetadataLoadedListener.html
index 6e851b6..4bd2a5c 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardMetadataLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardMetadataLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardScoresLoadedListener.html b/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardScoresLoadedListener.html
index 1de5a90..b78d488 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardScoresLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/OnLeaderboardScoresLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/OnScoreSubmittedListener.html b/docs/html/reference/com/google/android/gms/games/leaderboard/OnScoreSubmittedListener.html
index 3d55b86..ac36f82 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/OnScoreSubmittedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/OnScoreSubmittedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.Result.html b/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.Result.html
index 12cc4de..818a012 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.Result.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.Result.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.html b/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.html
index e9a08d5..3515b2a 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/SubmitScoreResult.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/leaderboard/package-summary.html b/docs/html/reference/com/google/android/gms/games/leaderboard/package-summary.html
index 552c383..012fc30 100644
--- a/docs/html/reference/com/google/android/gms/games/leaderboard/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/games/leaderboard/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/Invitation.html b/docs/html/reference/com/google/android/gms/games/multiplayer/Invitation.html
index 3a0bd5c..ffd6d9b 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/Invitation.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/Invitation.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationBuffer.html b/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationBuffer.html
index c164d34..b79cdcc 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationEntity.html b/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationEntity.html
index 8ff5f9e..a255b69 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationEntity.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/InvitationEntity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationReceivedListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationReceivedListener.html
index 164faed..6ad54f4 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationReceivedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationReceivedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationsLoadedListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationsLoadedListener.html
index 322d139..eb354d4 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationsLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/OnInvitationsLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/Participant.html b/docs/html/reference/com/google/android/gms/games/multiplayer/Participant.html
index c71146e..9483f1c 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/Participant.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/Participant.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantBuffer.html b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantBuffer.html
index 83d511e..228e0a0 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantBuffer.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantEntity.html b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantEntity.html
index ad1149d..c2e952f 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantEntity.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantEntity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantUtils.html b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantUtils.html
index 5e1b7b8..f3c1f11 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantUtils.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/ParticipantUtils.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/Participatable.html b/docs/html/reference/com/google/android/gms/games/multiplayer/Participatable.html
index 4c7f5e8..a06df5a 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/Participatable.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/Participatable.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/package-summary.html b/docs/html/reference/com/google/android/gms/games/multiplayer/package-summary.html
index d2be94a8..53708bc 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessage.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessage.html
index 1ddb9cf..a5821f5 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessage.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessage.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessageReceivedListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessageReceivedListener.html
index 182beeb..f1fb99d 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessageReceivedListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeMessageReceivedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeReliableMessageSentListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeReliableMessageSentListener.html
index e0f958c..82b27ef 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeReliableMessageSentListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeReliableMessageSentListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeSocket.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeSocket.html
index d6e5b42..86d51c5 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeSocket.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RealTimeSocket.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/Room.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/Room.html
index a317f76..5daba7f 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/Room.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/Room.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.Builder.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.Builder.html
index a9f8e25..f422aef4 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.Builder.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.html
index 6d0e58a..305bf58 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomConfig.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomEntity.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomEntity.html
index 75e890d..5457464 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomEntity.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomEntity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomStatusUpdateListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomStatusUpdateListener.html
index 4065ec6..bc4b593 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomStatusUpdateListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomStatusUpdateListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomUpdateListener.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomUpdateListener.html
index 108d7b7..8836837 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomUpdateListener.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/RoomUpdateListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/package-summary.html b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/package-summary.html
index a5cffbe..20da1fe 100644
--- a/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/games/multiplayer/realtime/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/games/package-summary.html b/docs/html/reference/com/google/android/gms/games/package-summary.html
index 53379f6..a12d9aa 100644
--- a/docs/html/reference/com/google/android/gms/games/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/games/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/gcm/GoogleCloudMessaging.html b/docs/html/reference/com/google/android/gms/gcm/GoogleCloudMessaging.html
index d16cea3..613f0ca 100644
--- a/docs/html/reference/com/google/android/gms/gcm/GoogleCloudMessaging.html
+++ b/docs/html/reference/com/google/android/gms/gcm/GoogleCloudMessaging.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/gcm/package-summary.html b/docs/html/reference/com/google/android/gms/gcm/package-summary.html
index f500dd2..886ce1c 100644
--- a/docs/html/reference/com/google/android/gms/gcm/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/gcm/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/ActivityRecognitionClient.html b/docs/html/reference/com/google/android/gms/location/ActivityRecognitionClient.html
index 5b2719c..25f355c 100644
--- a/docs/html/reference/com/google/android/gms/location/ActivityRecognitionClient.html
+++ b/docs/html/reference/com/google/android/gms/location/ActivityRecognitionClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/ActivityRecognitionResult.html b/docs/html/reference/com/google/android/gms/location/ActivityRecognitionResult.html
index c05f728..7f30cb7 100644
--- a/docs/html/reference/com/google/android/gms/location/ActivityRecognitionResult.html
+++ b/docs/html/reference/com/google/android/gms/location/ActivityRecognitionResult.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/DetectedActivity.html b/docs/html/reference/com/google/android/gms/location/DetectedActivity.html
index b1b63ca..b275a22 100644
--- a/docs/html/reference/com/google/android/gms/location/DetectedActivity.html
+++ b/docs/html/reference/com/google/android/gms/location/DetectedActivity.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/Geofence.Builder.html b/docs/html/reference/com/google/android/gms/location/Geofence.Builder.html
index e90c228..726568c 100644
--- a/docs/html/reference/com/google/android/gms/location/Geofence.Builder.html
+++ b/docs/html/reference/com/google/android/gms/location/Geofence.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/Geofence.html b/docs/html/reference/com/google/android/gms/location/Geofence.html
index 4abc3e5..f5f9af4 100644
--- a/docs/html/reference/com/google/android/gms/location/Geofence.html
+++ b/docs/html/reference/com/google/android/gms/location/Geofence.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationClient.OnAddGeofencesResultListener.html b/docs/html/reference/com/google/android/gms/location/LocationClient.OnAddGeofencesResultListener.html
index 6744610..90cb569 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationClient.OnAddGeofencesResultListener.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationClient.OnAddGeofencesResultListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationClient.OnRemoveGeofencesResultListener.html b/docs/html/reference/com/google/android/gms/location/LocationClient.OnRemoveGeofencesResultListener.html
index d5c9fdb..0e41b15 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationClient.OnRemoveGeofencesResultListener.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationClient.OnRemoveGeofencesResultListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationClient.html b/docs/html/reference/com/google/android/gms/location/LocationClient.html
index c083d31..7981ce9 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationClient.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationListener.html b/docs/html/reference/com/google/android/gms/location/LocationListener.html
index 12befe4..3a9891b 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationListener.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationRequest.html b/docs/html/reference/com/google/android/gms/location/LocationRequest.html
index 711374b..bef3ede 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationRequest.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationRequest.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/LocationStatusCodes.html b/docs/html/reference/com/google/android/gms/location/LocationStatusCodes.html
index b9e5968..b509bf7 100644
--- a/docs/html/reference/com/google/android/gms/location/LocationStatusCodes.html
+++ b/docs/html/reference/com/google/android/gms/location/LocationStatusCodes.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/location/package-summary.html b/docs/html/reference/com/google/android/gms/location/package-summary.html
index ea7798e..568752c 100644
--- a/docs/html/reference/com/google/android/gms/location/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/location/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/CameraUpdate.html b/docs/html/reference/com/google/android/gms/maps/CameraUpdate.html
index 8295ce0..05e042e 100644
--- a/docs/html/reference/com/google/android/gms/maps/CameraUpdate.html
+++ b/docs/html/reference/com/google/android/gms/maps/CameraUpdate.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/CameraUpdateFactory.html b/docs/html/reference/com/google/android/gms/maps/CameraUpdateFactory.html
index f4684cc..71784c9 100644
--- a/docs/html/reference/com/google/android/gms/maps/CameraUpdateFactory.html
+++ b/docs/html/reference/com/google/android/gms/maps/CameraUpdateFactory.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.CancelableCallback.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.CancelableCallback.html
index 6ddaed5a..cb696d4 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.CancelableCallback.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.CancelableCallback.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.InfoWindowAdapter.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.InfoWindowAdapter.html
index 8c1885e..255094c 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.InfoWindowAdapter.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.InfoWindowAdapter.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnCameraChangeListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnCameraChangeListener.html
index 356776e..51efee1 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnCameraChangeListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnCameraChangeListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnInfoWindowClickListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnInfoWindowClickListener.html
index 748eb5e..08e1945 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnInfoWindowClickListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnInfoWindowClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapClickListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapClickListener.html
index be3c396..1177b11 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapClickListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLoadedCallback.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLoadedCallback.html
index 10c6904..e3cd6b1 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLoadedCallback.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLoadedCallback.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLongClickListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLongClickListener.html
index 2811b2e..eca8a32 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLongClickListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMapLongClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerClickListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerClickListener.html
index 3f5ef8b..5a43126 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerClickListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerDragListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerDragListener.html
index dffd596..9ad543f 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerDragListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMarkerDragListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationButtonClickListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationButtonClickListener.html
index 2163ac9..9ee8148 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationButtonClickListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationButtonClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationChangeListener.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationChangeListener.html
index 2938e8a..6d3ec5a 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationChangeListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.OnMyLocationChangeListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.SnapshotReadyCallback.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.SnapshotReadyCallback.html
index 4ce045e..7ca6b21 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.SnapshotReadyCallback.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.SnapshotReadyCallback.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMap.html b/docs/html/reference/com/google/android/gms/maps/GoogleMap.html
index 4ec1355..b5161c4 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMap.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMap.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/GoogleMapOptions.html b/docs/html/reference/com/google/android/gms/maps/GoogleMapOptions.html
index c4cc20e..123087f 100644
--- a/docs/html/reference/com/google/android/gms/maps/GoogleMapOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/GoogleMapOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/LocationSource.OnLocationChangedListener.html b/docs/html/reference/com/google/android/gms/maps/LocationSource.OnLocationChangedListener.html
index e6e0593..7f2a863 100644
--- a/docs/html/reference/com/google/android/gms/maps/LocationSource.OnLocationChangedListener.html
+++ b/docs/html/reference/com/google/android/gms/maps/LocationSource.OnLocationChangedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/LocationSource.html b/docs/html/reference/com/google/android/gms/maps/LocationSource.html
index d30c652..4c0f63f 100644
--- a/docs/html/reference/com/google/android/gms/maps/LocationSource.html
+++ b/docs/html/reference/com/google/android/gms/maps/LocationSource.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/MapFragment.html b/docs/html/reference/com/google/android/gms/maps/MapFragment.html
index 41131993..4d196eb 100644
--- a/docs/html/reference/com/google/android/gms/maps/MapFragment.html
+++ b/docs/html/reference/com/google/android/gms/maps/MapFragment.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/MapView.html b/docs/html/reference/com/google/android/gms/maps/MapView.html
index 0798249..e3e8697 100644
--- a/docs/html/reference/com/google/android/gms/maps/MapView.html
+++ b/docs/html/reference/com/google/android/gms/maps/MapView.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/MapsInitializer.html b/docs/html/reference/com/google/android/gms/maps/MapsInitializer.html
index da53ea6..335f4ca 100644
--- a/docs/html/reference/com/google/android/gms/maps/MapsInitializer.html
+++ b/docs/html/reference/com/google/android/gms/maps/MapsInitializer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/Projection.html b/docs/html/reference/com/google/android/gms/maps/Projection.html
index b117307..9f1339f 100644
--- a/docs/html/reference/com/google/android/gms/maps/Projection.html
+++ b/docs/html/reference/com/google/android/gms/maps/Projection.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/SupportMapFragment.html b/docs/html/reference/com/google/android/gms/maps/SupportMapFragment.html
index 87dc7a0..23f3c7f 100644
--- a/docs/html/reference/com/google/android/gms/maps/SupportMapFragment.html
+++ b/docs/html/reference/com/google/android/gms/maps/SupportMapFragment.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/UiSettings.html b/docs/html/reference/com/google/android/gms/maps/UiSettings.html
index 21ee737..650d6ff 100644
--- a/docs/html/reference/com/google/android/gms/maps/UiSettings.html
+++ b/docs/html/reference/com/google/android/gms/maps/UiSettings.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptor.html b/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptor.html
index 629875d..cb5fd6f 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptor.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptor.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptorFactory.html b/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptorFactory.html
index 0c04cdf..680a6fb 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptorFactory.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/BitmapDescriptorFactory.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.Builder.html b/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.Builder.html
index 4348e30..f27f364 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.Builder.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.html b/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.html
index 51c897e..d7872e6 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/CameraPosition.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/Circle.html b/docs/html/reference/com/google/android/gms/maps/model/Circle.html
index 7331a35..203b58d 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/Circle.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/Circle.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/CircleOptions.html b/docs/html/reference/com/google/android/gms/maps/model/CircleOptions.html
index 2ce4d544..097d724 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/CircleOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/CircleOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/GroundOverlay.html b/docs/html/reference/com/google/android/gms/maps/model/GroundOverlay.html
index 37e2209..659dab1 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/GroundOverlay.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/GroundOverlay.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/GroundOverlayOptions.html b/docs/html/reference/com/google/android/gms/maps/model/GroundOverlayOptions.html
index ab48973..f50b9ff 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/GroundOverlayOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/GroundOverlayOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/LatLng.html b/docs/html/reference/com/google/android/gms/maps/model/LatLng.html
index a882cc0..9c3a3c1 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/LatLng.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/LatLng.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.Builder.html b/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.Builder.html
index 6b7f7ab..9f624ae 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.Builder.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.html b/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.html
index 5a3b9bd..3060a33 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/LatLngBounds.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/Marker.html b/docs/html/reference/com/google/android/gms/maps/model/Marker.html
index eadb9f6..caec06d 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/Marker.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/Marker.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/MarkerOptions.html b/docs/html/reference/com/google/android/gms/maps/model/MarkerOptions.html
index becca22..8e1288b 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/MarkerOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/MarkerOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/Polygon.html b/docs/html/reference/com/google/android/gms/maps/model/Polygon.html
index 6767f94..31b6184 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/Polygon.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/Polygon.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/PolygonOptions.html b/docs/html/reference/com/google/android/gms/maps/model/PolygonOptions.html
index fc889a6e..c71883c 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/PolygonOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/PolygonOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/Polyline.html b/docs/html/reference/com/google/android/gms/maps/model/Polyline.html
index 35c59f4..8da560c 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/Polyline.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/Polyline.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/PolylineOptions.html b/docs/html/reference/com/google/android/gms/maps/model/PolylineOptions.html
index b260f58..d25b709 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/PolylineOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/PolylineOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/RuntimeRemoteException.html b/docs/html/reference/com/google/android/gms/maps/model/RuntimeRemoteException.html
index 61071a0..adda6a0 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/RuntimeRemoteException.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/RuntimeRemoteException.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/Tile.html b/docs/html/reference/com/google/android/gms/maps/model/Tile.html
index 9fd011b..272d419 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/Tile.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/Tile.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/TileOverlay.html b/docs/html/reference/com/google/android/gms/maps/model/TileOverlay.html
index 2018867..85712b8 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/TileOverlay.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/TileOverlay.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/TileOverlayOptions.html b/docs/html/reference/com/google/android/gms/maps/model/TileOverlayOptions.html
index 2f4b7fb..819486e 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/TileOverlayOptions.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/TileOverlayOptions.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/TileProvider.html b/docs/html/reference/com/google/android/gms/maps/model/TileProvider.html
index e093cc7..672f0ef 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/TileProvider.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/TileProvider.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/UrlTileProvider.html b/docs/html/reference/com/google/android/gms/maps/model/UrlTileProvider.html
index 5b25b14..8a10d11 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/UrlTileProvider.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/UrlTileProvider.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/VisibleRegion.html b/docs/html/reference/com/google/android/gms/maps/model/VisibleRegion.html
index 80cc1c4..b4fb00f4 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/VisibleRegion.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/VisibleRegion.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/model/package-summary.html b/docs/html/reference/com/google/android/gms/maps/model/package-summary.html
index 21e5538..067647a 100644
--- a/docs/html/reference/com/google/android/gms/maps/model/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/maps/model/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/maps/package-summary.html b/docs/html/reference/com/google/android/gms/maps/package-summary.html
index ed2100c..9f61758 100644
--- a/docs/html/reference/com/google/android/gms/maps/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/maps/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/package-summary.html b/docs/html/reference/com/google/android/gms/package-summary.html
index c703b46..b31dbe7 100644
--- a/docs/html/reference/com/google/android/gms/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.OnPanoramaInfoLoadedListener.html b/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.OnPanoramaInfoLoadedListener.html
index 3357549..415bdc3 100644
--- a/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.OnPanoramaInfoLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.OnPanoramaInfoLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.html b/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.html
index 21714a3..36cacac 100644
--- a/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.html
+++ b/docs/html/reference/com/google/android/gms/panorama/PanoramaClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/panorama/package-summary.html b/docs/html/reference/com/google/android/gms/panorama/package-summary.html
index f132452..59712ec 100644
--- a/docs/html/reference/com/google/android/gms/panorama/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/panorama/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.Builder.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.Builder.html
index 8158a2b..fe76201 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.Builder.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnAccessRevokedListener.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnAccessRevokedListener.html
index 47849f4..a604f72 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnAccessRevokedListener.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnAccessRevokedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnMomentsLoadedListener.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnMomentsLoadedListener.html
index 43486e0..a7c5abc 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnMomentsLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnMomentsLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnPeopleLoadedListener.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnPeopleLoadedListener.html
index 8285506..b3844c3 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.OnPeopleLoadedListener.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.OnPeopleLoadedListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.OrderBy.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.OrderBy.html
index 0d9d025..5aa4ec0 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.OrderBy.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.OrderBy.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusClient.html b/docs/html/reference/com/google/android/gms/plus/PlusClient.html
index 194dfa8..91b64bf 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusClient.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.DefaultOnPlusOneClickListener.html b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.DefaultOnPlusOneClickListener.html
index d0b19cc..ea048d2 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.DefaultOnPlusOneClickListener.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.DefaultOnPlusOneClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.OnPlusOneClickListener.html b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.OnPlusOneClickListener.html
index 9f5d227..e1fa665 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.OnPlusOneClickListener.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.OnPlusOneClickListener.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.html b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.html
index a9c5566..37d9292 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusOneButton.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusOneButton.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusOneButtonWithPopup.html b/docs/html/reference/com/google/android/gms/plus/PlusOneButtonWithPopup.html
index 8072051..4520e14 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusOneButtonWithPopup.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusOneButtonWithPopup.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusOneDummyView.html b/docs/html/reference/com/google/android/gms/plus/PlusOneDummyView.html
index 27ecdbd..237ab42 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusOneDummyView.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusOneDummyView.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusShare.Builder.html b/docs/html/reference/com/google/android/gms/plus/PlusShare.Builder.html
index e983cfc..d3bf559 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusShare.Builder.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusShare.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/PlusShare.html b/docs/html/reference/com/google/android/gms/plus/PlusShare.html
index 4382746..ece13ed 100644
--- a/docs/html/reference/com/google/android/gms/plus/PlusShare.html
+++ b/docs/html/reference/com/google/android/gms/plus/PlusShare.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.Builder.html b/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.Builder.html
index b443b38..b5812bb 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.Builder.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.html b/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.html
index f5e6595..6d27fa1 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/ItemScope.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.Builder.html b/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.Builder.html
index 63ffc51..eec5ef0 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.Builder.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.html b/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.html
index 8f22f7f..800f78a 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/Moment.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/MomentBuffer.html b/docs/html/reference/com/google/android/gms/plus/model/moments/MomentBuffer.html
index 6a69fed..148e933 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/MomentBuffer.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/MomentBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/moments/package-summary.html b/docs/html/reference/com/google/android/gms/plus/model/moments/package-summary.html
index 86485d4..6a34052 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/moments/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/moments/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.AgeRange.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.AgeRange.html
index ca9aa93..1516706 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.AgeRange.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.AgeRange.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverInfo.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverInfo.html
index d311a63..343d55c 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverInfo.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverInfo.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverPhoto.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverPhoto.html
index 8731ce7..28adbcd 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverPhoto.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.CoverPhoto.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.Layout.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.Layout.html
index a0f829a..8b1efdd 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.Layout.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.Layout.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.html
index dc93b4c..d4a750b 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Cover.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Gender.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Gender.html
index 2bbdb30..7ce05ed 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Gender.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Gender.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Image.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Image.html
index 77364bd..fc270ac 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Image.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Image.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Name.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Name.html
index c8d6d79..92b7d6e 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Name.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Name.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.ObjectType.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.ObjectType.html
index 3667ddc..5501f7d 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.ObjectType.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.ObjectType.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.Type.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.Type.html
index 027814b..2ea8479 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.Type.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.Type.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.html
index 82b1be5..e03015d 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Organizations.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.PlacesLived.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.PlacesLived.html
index 231aba1..f798987 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.PlacesLived.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.PlacesLived.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.RelationshipStatus.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.RelationshipStatus.html
index 82730d3b..eb43678 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.RelationshipStatus.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.RelationshipStatus.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.Type.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.Type.html
index 4830c12..c20e1e9 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.Type.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.Type.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.html
index 0709156..7a53481 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.Urls.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/Person.html b/docs/html/reference/com/google/android/gms/plus/model/people/Person.html
index 7cf1032..9f9cc2b 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/Person.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/Person.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/PersonBuffer.html b/docs/html/reference/com/google/android/gms/plus/model/people/PersonBuffer.html
index aaa6d9c..0a4a2ba 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/PersonBuffer.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/PersonBuffer.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/model/people/package-summary.html b/docs/html/reference/com/google/android/gms/plus/model/people/package-summary.html
index 5c493ca..d7b654a 100644
--- a/docs/html/reference/com/google/android/gms/plus/model/people/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/plus/model/people/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/plus/package-summary.html b/docs/html/reference/com/google/android/gms/plus/package-summary.html
index 7f6dfad..9cc6c42 100644
--- a/docs/html/reference/com/google/android/gms/plus/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/plus/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/Address.html b/docs/html/reference/com/google/android/gms/wallet/Address.html
index 37e715d..4cd1b11 100644
--- a/docs/html/reference/com/google/android/gms/wallet/Address.html
+++ b/docs/html/reference/com/google/android/gms/wallet/Address.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/Cart.Builder.html b/docs/html/reference/com/google/android/gms/wallet/Cart.Builder.html
index 935b05e..9dd6929 100644
--- a/docs/html/reference/com/google/android/gms/wallet/Cart.Builder.html
+++ b/docs/html/reference/com/google/android/gms/wallet/Cart.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/Cart.html b/docs/html/reference/com/google/android/gms/wallet/Cart.html
index 4a3ef7a..a86823f 100644
--- a/docs/html/reference/com/google/android/gms/wallet/Cart.html
+++ b/docs/html/reference/com/google/android/gms/wallet/Cart.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/EnableWalletOptimizationReceiver.html b/docs/html/reference/com/google/android/gms/wallet/EnableWalletOptimizationReceiver.html
index 1e2422c..813cf1c 100644
--- a/docs/html/reference/com/google/android/gms/wallet/EnableWalletOptimizationReceiver.html
+++ b/docs/html/reference/com/google/android/gms/wallet/EnableWalletOptimizationReceiver.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/FullWallet.html b/docs/html/reference/com/google/android/gms/wallet/FullWallet.html
index 60a5b92..3fe6ec2 100644
--- a/docs/html/reference/com/google/android/gms/wallet/FullWallet.html
+++ b/docs/html/reference/com/google/android/gms/wallet/FullWallet.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.Builder.html b/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.Builder.html
index 9124a15..a92cd58 100644
--- a/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.Builder.html
+++ b/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.html b/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.html
index 816067f..e75b0ca 100644
--- a/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.html
+++ b/docs/html/reference/com/google/android/gms/wallet/FullWalletRequest.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/LineItem.Builder.html b/docs/html/reference/com/google/android/gms/wallet/LineItem.Builder.html
index ed4a156..dd832e1 100644
--- a/docs/html/reference/com/google/android/gms/wallet/LineItem.Builder.html
+++ b/docs/html/reference/com/google/android/gms/wallet/LineItem.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/LineItem.Role.html b/docs/html/reference/com/google/android/gms/wallet/LineItem.Role.html
index f00653f..992f817 100644
--- a/docs/html/reference/com/google/android/gms/wallet/LineItem.Role.html
+++ b/docs/html/reference/com/google/android/gms/wallet/LineItem.Role.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/LineItem.html b/docs/html/reference/com/google/android/gms/wallet/LineItem.html
index 466e5e5..cf7cfb7 100644
--- a/docs/html/reference/com/google/android/gms/wallet/LineItem.html
+++ b/docs/html/reference/com/google/android/gms/wallet/LineItem.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/LoyaltyWalletObject.html b/docs/html/reference/com/google/android/gms/wallet/LoyaltyWalletObject.html
index 5e73d64..02867c8 100644
--- a/docs/html/reference/com/google/android/gms/wallet/LoyaltyWalletObject.html
+++ b/docs/html/reference/com/google/android/gms/wallet/LoyaltyWalletObject.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/MaskedWallet.html b/docs/html/reference/com/google/android/gms/wallet/MaskedWallet.html
index 40047b8..a6501f96 100644
--- a/docs/html/reference/com/google/android/gms/wallet/MaskedWallet.html
+++ b/docs/html/reference/com/google/android/gms/wallet/MaskedWallet.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.Builder.html b/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.Builder.html
index 4e2d6b64..5f6d081 100644
--- a/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.Builder.html
+++ b/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.html b/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.html
index 10844b9..a45d761 100644
--- a/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.html
+++ b/docs/html/reference/com/google/android/gms/wallet/MaskedWalletRequest.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Builder.html b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Builder.html
index 6e62892..d5c29ea 100644
--- a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Builder.html
+++ b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Builder.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.Error.html b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.Error.html
index 8cab605..594363f 100644
--- a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.Error.html
+++ b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.Error.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.html b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.html
index 5282ce5..3a19e5d 100644
--- a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.html
+++ b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.Status.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.html b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.html
index d2a357f..a265dbf 100644
--- a/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.html
+++ b/docs/html/reference/com/google/android/gms/wallet/NotifyTransactionStatusRequest.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/OfferWalletObject.html b/docs/html/reference/com/google/android/gms/wallet/OfferWalletObject.html
index 558bbb6..0ddbae1 100644
--- a/docs/html/reference/com/google/android/gms/wallet/OfferWalletObject.html
+++ b/docs/html/reference/com/google/android/gms/wallet/OfferWalletObject.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/ProxyCard.html b/docs/html/reference/com/google/android/gms/wallet/ProxyCard.html
index 9cc1c28..3c2819c 100644
--- a/docs/html/reference/com/google/android/gms/wallet/ProxyCard.html
+++ b/docs/html/reference/com/google/android/gms/wallet/ProxyCard.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/WalletClient.html b/docs/html/reference/com/google/android/gms/wallet/WalletClient.html
index 654013c..b13e283 100644
--- a/docs/html/reference/com/google/android/gms/wallet/WalletClient.html
+++ b/docs/html/reference/com/google/android/gms/wallet/WalletClient.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
@@ -782,9 +793,9 @@
  new account and do not reuse the Google transaction ID associated with the old account - this is
  a new transaction.
  <p>
- We recommend that you <a href="http://getinstantbuy.withgoogle.com/">apply for API access</a>
- before starting development. During development, use the sandbox environment by specifying
- <code><a href="/reference/com/google/android/gms/wallet/WalletConstants.html#ENVIRONMENT_SANDBOX">ENVIRONMENT_SANDBOX</a></code> in the constructor.
+ We recommend that you <a class="external-link" href="http://getinstantbuy.withgoogle.com/">apply
+ for API access</a> before starting development. During development, use the sandbox environment by
+ specifying <code><a href="/reference/com/google/android/gms/wallet/WalletConstants.html#ENVIRONMENT_SANDBOX">ENVIRONMENT_SANDBOX</a></code> in the constructor.
 </p>
 
 
diff --git a/docs/html/reference/com/google/android/gms/wallet/WalletConstants.html b/docs/html/reference/com/google/android/gms/wallet/WalletConstants.html
index 3d61c1c..d3b4634 100644
--- a/docs/html/reference/com/google/android/gms/wallet/WalletConstants.html
+++ b/docs/html/reference/com/google/android/gms/wallet/WalletConstants.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -308,6 +309,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -375,6 +379,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -517,29 +525,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/com/google/android/gms/wallet/package-summary.html b/docs/html/reference/com/google/android/gms/wallet/package-summary.html
index 88436d1..49a4278 100644
--- a/docs/html/reference/com/google/android/gms/wallet/package-summary.html
+++ b/docs/html/reference/com/google/android/gms/wallet/package-summary.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -309,6 +310,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -376,6 +380,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -518,29 +526,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/reference/gms-packages.html b/docs/html/reference/gms-packages.html
index 47ee3bb..0a2450b 100644
--- a/docs/html/reference/gms-packages.html
+++ b/docs/html/reference/gms-packages.html
@@ -97,6 +97,7 @@
 <script src="/assets/js/android_3p-bundle.js" type="text/javascript"></script>
 <script type="text/javascript">
   var toRoot = "/";
+  var metaTags = [];
   var devsite = false;
 </script>
 <script src="/assets/js/docs.js" type="text/javascript"></script>
@@ -307,6 +308,9 @@
                         <li><a href="/google/index.html">Google Services</a>
                         </li>
                         
+                          <li><a href="/samples/index.html">Samples</a>
+                          </li>
+                        
                       </ul>
                     </li>
                     <li class="distribute last">
@@ -374,6 +378,10 @@
                   >Google Services</a>
                 </li>
                 
+                  <li class="samples"><a href="/samples/index.html"
+                    >Samples</a>
+                  </li>
+                
             </ul>
         </div>
         
@@ -516,29 +524,32 @@
 
 
 
-  <li class="nav-section">
+   <li class="nav-section">
       <div class="nav-section-header"><a href="/google/gcm/index.html">
         <span class="en">Google Cloud Messaging</span></a>
       </div>
       <ul>
+        <li><a href="/google/gcm/gcm.html">
+            <span class="en">Overview</span></a>
+        </li>
         <li><a href="/google/gcm/gs.html">
             <span class="en">Getting Started</span></a>
         </li>
-        <li><a href="/google/gcm/gcm.html">
-            <span class="en">Architectural Overview</span></a>
+        <li><a href="/google/gcm/client.html">
+            <span class="en">Implementing GCM Client</span></a>
         </li>
-         <li><a href="/google/gcm/ccs.html">
-              <span class="en">Cloud Connection Server</span></a>
+        <li class="nav-section"><div class="nav-section-header"><a href="/google/gcm/server.html">
+              <span class="en">Implementing GCM Server</span></a></div>
+              <ul>
+              <li><a href="/google/gcm/ccs.html">
+              <span class="en">CCS (XMPP)</span></a></li>
+              <li><a href="/google/gcm/http.html">
+              <span class="en">HTTP</span></a></li>
+              </ul>
         </li>
         <li><a href="/google/gcm/notifications.html">
               <span class="en">User Notifications</span></a>
         </li>
-        <li><a href="/google/gcm/client.html">
-            <span class="en">GCM Client</span></a>
-        </li>
-        <li><a href="/google/gcm/server.html">
-            <span class="en">GCM Server</span></a>
-        </li>
         <li><a href="/google/gcm/adv.html">
             <span class="en">Advanced Topics</span></a>
         </li>
diff --git a/docs/html/robots.txt b/docs/html/robots.txt
index 503e4b1..f522220 100644
--- a/docs/html/robots.txt
+++ b/docs/html/robots.txt
@@ -14,4 +14,5 @@
 Disallow: /shareables/
 Disallow: /guide/tutorials/
 Disallow: /guide/samples/
+Disallow: /community/
 Sitemap: http://developer.android.com/sitemap.txt
diff --git a/docs/html/samples/samples_toc.cs b/docs/html/samples/samples_toc.cs
index 18f7034..2007f22 100644
--- a/docs/html/samples/samples_toc.cs
+++ b/docs/html/samples/samples_toc.cs
@@ -1,6 +1,4 @@
-
 <ul id="nav" class="samples-nav">
-
 <script type="text/javascript">
 <!--
     buildToggleLists();
@@ -8,11 +6,9 @@
 //-->
 </script>
   <li class="nav-section">
-    <div class="nav-section-header empty"><a href="/samples/index.html">
+    <div class="nav-section-header empty"><a href="<?cs var:toroot ?>samples/index.html">
       <span class="en">About the Samples</span></a>
     </div>
   </li>
-
-
-  <li class="nav-section"><div class="nav-section-header"><a href="/samples/background.html" title="Background">Background</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/repeatingAlarm/index.html" title="repeatingAlarm">repeatingAlarm</a></div><ul><li><a href="/samples/repeatingAlarm/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/repeatingAlarm/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/repeatingAlarm/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/repeatingAlarm/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/repeatingAlarm/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/repeatingAlarm/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/repeatingAlarm/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/repeatingAlarm/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/repeatingAlarm/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/repeatingAlarm/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/repeatingAlarm/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/repeatingAlarm/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/repeatingAlarm/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/repeatingAlarm/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/repeatingAlarm/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.repeatingalarm">com.example.android.repeatingalarm/</a></div><ul><li><a href="/samples/repeatingAlarm/src/com.example.android.repeatingalarm/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/repeatingAlarm/src/com.example.android.repeatingalarm/RepeatingAlarmFragment.html" title="RepeatingAlarmFragment.java">RepeatingAlarmFragment.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/connectivity.html" title="Connectivity">Connectivity</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BluetoothLeGatt/index.html" title="BluetoothLeGatt">BluetoothLeGatt</a></div><ul><li><a href="/samples/BluetoothLeGatt/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BluetoothLeGatt/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/layout/actionbar_indeterminate_progress.html" title="actionbar_indeterminate_progress.xml">actionbar_indeterminate_progress.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/layout/gatt_services_characteristics.html" title="gatt_services_characteristics.xml">gatt_services_characteristics.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/layout/listitem_device.html" title="listitem_device.xml">listitem_device.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/menu/gatt_services.html" title="gatt_services.xml">gatt_services.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BluetoothLeGatt/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BluetoothLeGatt/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.bluetoothlegatt">com.example.android.bluetoothlegatt/</a></div><ul><li><a href="/samples/BluetoothLeGatt/src/com.example.android.bluetoothlegatt/BluetoothLeService.html" title="BluetoothLeService.java">BluetoothLeService.java</a></li><li><a href="/samples/BluetoothLeGatt/src/com.example.android.bluetoothlegatt/DeviceControlActivity.html" title="DeviceControlActivity.java">DeviceControlActivity.java</a></li><li><a href="/samples/BluetoothLeGatt/src/com.example.android.bluetoothlegatt/DeviceScanActivity.html" title="DeviceScanActivity.java">DeviceScanActivity.java</a></li><li><a href="/samples/BluetoothLeGatt/src/com.example.android.bluetoothlegatt/SampleGattAttributes.html" title="SampleGattAttributes.java">SampleGattAttributes.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/NetworkConnect/index.html" title="NetworkConnect">NetworkConnect</a></div><ul><li><a href="/samples/NetworkConnect/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/NetworkConnect/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/NetworkConnect/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/NetworkConnect/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/NetworkConnect/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/NetworkConnect/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/NetworkConnect/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/NetworkConnect/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/NetworkConnect/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/NetworkConnect/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/NetworkConnect/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/NetworkConnect/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/NetworkConnect/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/NetworkConnect/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/NetworkConnect/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.networkconnect">com.example.android.networkconnect/</a></div><ul><li><a href="/samples/NetworkConnect/src/com.example.android.networkconnect/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/NetworkConnect/src/com.example.android.networkconnect/SimpleTextFragment.html" title="SimpleTextFragment.java">SimpleTextFragment.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicNetworking/index.html" title="BasicNetworking">BasicNetworking</a></div><ul><li><a href="/samples/BasicNetworking/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicNetworking/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicNetworking/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicNetworking/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicNetworking/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicNetworking/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicNetworking/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicNetworking/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicNetworking/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicNetworking/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicNetworking/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicNetworking/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicNetworking/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicNetworking/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicNetworking/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicnetworking">com.example.android.basicnetworking/</a></div><ul><li><a href="/samples/BasicNetworking/src/com.example.android.basicnetworking/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.basicnetworking/SimpleTextFragment.html" title="SimpleTextFragment.java">SimpleTextFragment.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicNetworking/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicSyncAdapter/index.html" title="BasicSyncAdapter">BasicSyncAdapter</a></div><ul><li><a href="/samples/BasicSyncAdapter/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicSyncAdapter/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/drawable-xhdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/BasicSyncAdapter/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/layout/actionbar_indeterminate_progress.html" title="actionbar_indeterminate_progress.xml">actionbar_indeterminate_progress.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/layout/activity_entry_list.html" title="activity_entry_list.xml">activity_entry_list.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/values/attrs.html" title="attrs.xml">attrs.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values/dimen.html" title="dimen.xml">dimen.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="xml">xml/</a></div><ul><li><a href="/samples/BasicSyncAdapter/res/xml/authenticator.html" title="authenticator.xml">authenticator.xml</a></li><li><a href="/samples/BasicSyncAdapter/res/xml/syncadapter.html" title="syncadapter.xml">syncadapter.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicsyncadapter">com.example.android.basicsyncadapter/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/EntryListActivity.html" title="EntryListActivity.java">EntryListActivity.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/EntryListFragment.html" title="EntryListFragment.java">EntryListFragment.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/SyncAdapter.html" title="SyncAdapter.java">SyncAdapter.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/SyncService.html" title="SyncService.java">SyncService.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/SyncUtils.html" title="SyncUtils.java">SyncUtils.java</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="net">net/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/net/FeedParser.html" title="FeedParser.java">FeedParser.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="provider">provider/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/provider/FeedContract.html" title="FeedContract.java">FeedContract.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.basicsyncadapter/provider/FeedProvider.html" title="FeedProvider.java">FeedProvider.java</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="accounts">accounts/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/accounts/GenericAccountService.html" title="GenericAccountService.java">GenericAccountService.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="db">db/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/db/SelectionBuilder.html" title="SelectionBuilder.java">SelectionBuilder.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicSyncAdapter/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/content.html" title="Content">Content</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicContactables/index.html" title="BasicContactables">BasicContactables</a></div><ul><li><a href="/samples/BasicContactables/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicContactables/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicContactables/res/drawable-hdpi/ic_search_api_holo_light.html" title="ic_search_api_holo_light.png">ic_search_api_holo_light.png</a></li><li><a href="/samples/BasicContactables/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicContactables/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicContactables/res/drawable-mdpi/ic_search_api_holo_light.html" title="ic_search_api_holo_light.png">ic_search_api_holo_light.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicContactables/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicContactables/res/drawable-xhdpi/ic_search_api_holo_light.html" title="ic_search_api_holo_light.png">ic_search_api_holo_light.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicContactables/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicContactables/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicContactables/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicContactables/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicContactables/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicContactables/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicContactables/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicContactables/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicContactables/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicContactables/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="xml">xml/</a></div><ul><li><a href="/samples/BasicContactables/res/xml/searchable.html" title="searchable.xml">searchable.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basiccontactables">com.example.android.basiccontactables/</a></div><ul><li><a href="/samples/BasicContactables/src/com.example.android.basiccontactables/ContactablesLoaderCallbacks.html" title="ContactablesLoaderCallbacks.java">ContactablesLoaderCallbacks.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.basiccontactables/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicContactables/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/AppRestrictions/index.html" title="AppRestrictions">AppRestrictions</a></div><ul><li><a href="/samples/AppRestrictions/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/AppRestrictions/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/AppRestrictions/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/AppRestrictions/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/AppRestrictions/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/AppRestrictions/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/AppRestrictions/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/AppRestrictions/res/layout/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/AppRestrictions/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/AppRestrictions/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/AppRestrictions/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/AppRestrictions/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/AppRestrictions/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/AppRestrictions/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="xml">xml/</a></div><ul><li><a href="/samples/AppRestrictions/res/xml/custom_prefs.html" title="custom_prefs.xml">custom_prefs.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.apprestrictions">com.example.android.apprestrictions/</a></div><ul><li><a href="/samples/AppRestrictions/src/com.example.android.apprestrictions/CustomRestrictionsActivity.html" title="CustomRestrictionsActivity.java">CustomRestrictionsActivity.java</a></li><li><a href="/samples/AppRestrictions/src/com.example.android.apprestrictions/CustomRestrictionsFragment.html" title="CustomRestrictionsFragment.java">CustomRestrictionsFragment.java</a></li><li><a href="/samples/AppRestrictions/src/com.example.android.apprestrictions/GetRestrictionsReceiver.html" title="GetRestrictionsReceiver.java">GetRestrictionsReceiver.java</a></li><li><a href="/samples/AppRestrictions/src/com.example.android.apprestrictions/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/StorageClient/index.html" title="StorageClient">StorageClient</a></div><ul><li><a href="/samples/StorageClient/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/StorageClient/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/StorageClient/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/StorageClient/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/StorageClient/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/StorageClient/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/StorageClient/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/StorageClient/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/StorageClient/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/StorageClient/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/StorageClient/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/StorageClient/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/StorageClient/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/StorageClient/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/StorageClient/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/StorageClient/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.storageclient">com.example.android.storageclient/</a></div><ul><li><a href="/samples/StorageClient/src/com.example.android.storageclient/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/StorageClient/src/com.example.android.storageclient/StorageClientFragment.html" title="StorageClientFragment.java">StorageClientFragment.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/input.html" title="Input">Input</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicMultitouch/index.html" title="BasicMultitouch">BasicMultitouch</a></div><ul><li><a href="/samples/BasicMultitouch/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicMultitouch/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicMultitouch/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicMultitouch/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicMultitouch/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicMultitouch/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicMultitouch/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicMultitouch/res/layout/layout_mainactivity.html" title="layout_mainactivity.xml">layout_mainactivity.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicMultitouch/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicMultitouch/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMultitouch/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicMultitouch/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicMultitouch/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMultitouch/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v11">values-v11/</a></div><ul><li><a href="/samples/BasicMultitouch/res/values-v11/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v14">values-v14/</a></div><ul><li><a href="/samples/BasicMultitouch/res/values-v14/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicmultitouch">com.example.android.basicmultitouch/</a></div><ul><li><a href="/samples/BasicMultitouch/src/com.example.android.basicmultitouch/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.basicmultitouch/Pools.html" title="Pools.java">Pools.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.basicmultitouch/TouchDisplayView.html" title="TouchDisplayView.java">TouchDisplayView.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicMultitouch/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicGestureDetect/index.html" title="BasicGestureDetect">BasicGestureDetect</a></div><ul><li><a href="/samples/BasicGestureDetect/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicGestureDetect/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicGestureDetect/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicGestureDetect/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicGestureDetect/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicGestureDetect/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicGestureDetect/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicgesturedetect">com.example.android.basicgesturedetect/</a></div><ul><li><a href="/samples/BasicGestureDetect/src/com.example.android.basicgesturedetect/BasicGestureDetectFragment.html" title="BasicGestureDetectFragment.java">BasicGestureDetectFragment.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.basicgesturedetect/GestureListener.html" title="GestureListener.java">GestureListener.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.basicgesturedetect/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicGestureDetect/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/media.html" title="Media">Media</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicMediaRouter/index.html" title="BasicMediaRouter">BasicMediaRouter</a></div><ul><li><a href="/samples/BasicMediaRouter/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicMediaRouter/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicMediaRouter/res/layout/display.html" title="display.xml">display.xml</a></li><li><a href="/samples/BasicMediaRouter/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicMediaRouter/res/values/colors.html" title="colors.xml">colors.xml</a></li><li><a href="/samples/BasicMediaRouter/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMediaRouter/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicMediaRouter/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicMediaRouter/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMediaRouter/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicmediarouter">com.example.android.basicmediarouter/</a></div><ul><li><a href="/samples/BasicMediaRouter/src/com.example.android.basicmediarouter/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.basicmediarouter/SamplePresentation.html" title="SamplePresentation.java">SamplePresentation.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicMediaRouter/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicMediaDecoder/index.html" title="BasicMediaDecoder">BasicMediaDecoder</a></div><ul><li><a href="/samples/BasicMediaDecoder/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable">drawable/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/drawable/selector_play.html" title="selector_play.xml">selector_play.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/drawable-hdpi/ic_action_play.html" title="ic_action_play.png">ic_action_play.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-hdpi/ic_action_play_disabled.html" title="ic_action_play_disabled.png">ic_action_play_disabled.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/drawable-mdpi/ic_action_play.html" title="ic_action_play.png">ic_action_play.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-mdpi/ic_action_play_disabled.html" title="ic_action_play_disabled.png">ic_action_play_disabled.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/drawable-xhdpi/ic_action_play.html" title="ic_action_play.png">ic_action_play.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-xhdpi/ic_action_play_disabled.html" title="ic_action_play_disabled.png">ic_action_play_disabled.png</a></li><li><a href="/samples/BasicMediaDecoder/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicMediaDecoder/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/menu/action_menu.html" title="action_menu.xml">action_menu.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="raw">raw/</a></div><ul><li>vid_bigbuckbunny.mp4</li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicMediaDecoder/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMediaDecoder/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicMediaDecoder/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicMediaDecoder/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicMediaDecoder/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicmediadecoder">com.example.android.basicmediadecoder/</a></div><ul><li><a href="/samples/BasicMediaDecoder/src/com.example.android.basicmediadecoder/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.media">com.example.android.common.media/</a></div><ul><li><a href="/samples/BasicMediaDecoder/src/com.example.android.common.media/CameraHelper.html" title="CameraHelper.java">CameraHelper.java</a></li><li><a href="/samples/BasicMediaDecoder/src/com.example.android.common.media/MediaCodecWrapper.html" title="MediaCodecWrapper.java">MediaCodecWrapper.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/security.html" title="Security">Security</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicAndroidKeyStore/index.html" title="BasicAndroidKeyStore">BasicAndroidKeyStore</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicAndroidKeyStore/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicAndroidKeyStore/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicAndroidKeyStore/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicAndroidKeyStore/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicAndroidKeyStore/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicandroidkeystore">com.example.android.basicandroidkeystore/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.basicandroidkeystore/BasicAndroidKeyStoreFragment.html" title="BasicAndroidKeyStoreFragment.java">BasicAndroidKeyStoreFragment.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.basicandroidkeystore/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.basicandroidkeystore/SecurityConstants.html" title="SecurityConstants.java">SecurityConstants.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicAndroidKeyStore/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/testing.html" title="Testing">Testing</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/ActivityInstrumentation/index.html" title="ActivityInstrumentation">ActivityInstrumentation</a></div><ul><li><a href="/samples/ActivityInstrumentation/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ActivityInstrumentation/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/ActivityInstrumentation/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/ActivityInstrumentation/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ActivityInstrumentation/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/ActivityInstrumentation/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ActivityInstrumentation/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/ActivityInstrumentation/res/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.activityinstrumentation">com.example.android.activityinstrumentation/</a></div><ul><li><a href="/samples/ActivityInstrumentation/src/com.example.android.activityinstrumentation/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/ActivityInstrumentation/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/ui.html" title="UI">UI</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicAccessibility/index.html" title="BasicAccessibility">BasicAccessibility</a></div><ul><li><a href="/samples/BasicAccessibility/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicAccessibility/res/drawable-hdpi/ic_action_discard.html" title="ic_action_discard.png">ic_action_discard.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-hdpi/ic_action_info.html" title="ic_action_info.png">ic_action_info.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-hdpi/partly_cloudy.html" title="partly_cloudy.png">partly_cloudy.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicAccessibility/res/drawable-mdpi/ic_action_discard.html" title="ic_action_discard.png">ic_action_discard.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-mdpi/ic_action_info.html" title="ic_action_info.png">ic_action_info.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicAccessibility/res/drawable-xhdpi/ic_action_discard.html" title="ic_action_discard.png">ic_action_discard.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-xhdpi/ic_action_info.html" title="ic_action_info.png">ic_action_info.png</a></li><li><a href="/samples/BasicAccessibility/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicAccessibility/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicAccessibility/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicAccessibility/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicAccessibility/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicAccessibility/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicAccessibility/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicAccessibility/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicAccessibility/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicAccessibility/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/BasicAccessibility/res/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicaccessibility">com.example.android.basicaccessibility/</a></div><ul><li><a href="/samples/BasicAccessibility/src/com.example.android.basicaccessibility/DialView.html" title="DialView.java">DialView.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.basicaccessibility/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicAccessibility/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/HorizontalPaging/index.html" title="HorizontalPaging">HorizontalPaging</a></div><ul><li><a href="/samples/HorizontalPaging/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/HorizontalPaging/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/HorizontalPaging/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/HorizontalPaging/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/HorizontalPaging/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/HorizontalPaging/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/HorizontalPaging/res/layout/fragment_main_dummy.html" title="fragment_main_dummy.xml">fragment_main_dummy.xml</a></li><li><a href="/samples/HorizontalPaging/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/HorizontalPaging/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/HorizontalPaging/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/HorizontalPaging/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/HorizontalPaging/res/values/styles.html" title="styles.xml">styles.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/HorizontalPaging/res/values/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/HorizontalPaging/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/HorizontalPaging/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.horizontalpaging">com.example.android.horizontalpaging/</a></div><ul><li><a href="/samples/HorizontalPaging/src/com.example.android.horizontalpaging/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/ShareActionProvider/index.html" title="ShareActionProvider">ShareActionProvider</a></div><ul><li><a href="/samples/ShareActionProvider/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/ShareActionProvider/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ShareActionProvider/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/ShareActionProvider/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/ShareActionProvider/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/ShareActionProvider/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/ShareActionProvider/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/ShareActionProvider/res/layout/item_image.html" title="item_image.xml">item_image.xml</a></li><li><a href="/samples/ShareActionProvider/res/layout/item_text.html" title="item_text.xml">item_text.xml</a></li><li><a href="/samples/ShareActionProvider/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/ShareActionProvider/res/menu/main_menu.html" title="main_menu.xml">main_menu.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/ShareActionProvider/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/ShareActionProvider/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ShareActionProvider/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/ShareActionProvider/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/ShareActionProvider/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ShareActionProvider/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.actionbarcompat.shareactionprovider">com.example.android.actionbarcompat.shareactionprovider/</a></div><ul><li><a href="/samples/ShareActionProvider/src/com.example.android.actionbarcompat.shareactionprovider/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="content">content/</a></div><ul><li><a href="/samples/ShareActionProvider/src/com.example.android.actionbarcompat.shareactionprovider/content/AssetProvider.html" title="AssetProvider.java">AssetProvider.java</a></li><li><a href="/samples/ShareActionProvider/src/com.example.android.actionbarcompat.shareactionprovider/content/ContentItem.html" title="ContentItem.java">ContentItem.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/Styled/index.html" title="Styled">Styled</a></div><ul><li><a href="/samples/Styled/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable">drawable/</a></div><ul><li><a href="/samples/Styled/res/drawable/pressed_background.html" title="pressed_background.xml">pressed_background.xml</a></li><li><a href="/samples/Styled/res/drawable/progress_horizontal.html" title="progress_horizontal.xml">progress_horizontal.xml</a></li><li><a href="/samples/Styled/res/drawable/selectable_background.html" title="selectable_background.xml">selectable_background.xml</a></li><li><a href="/samples/Styled/res/drawable/spinner_background_ab.html" title="spinner_background_ab.xml">spinner_background_ab.xml</a></li><li><a href="/samples/Styled/res/drawable/tab_indicator_ab.html" title="tab_indicator_ab.xml">tab_indicator_ab.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/Styled/res/drawable-hdpi/ab_bottom_solid_styled.9.html" title="ab_bottom_solid_styled.9.png">ab_bottom_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ab_solid_styled.9.html" title="ab_solid_styled.9.png">ab_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ab_stacked_solid_styled.9.html" title="ab_stacked_solid_styled.9.png">ab_stacked_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/list_focused_styled.9.html" title="list_focused_styled.9.png">list_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/menu_dropdown_panel_styled.9.html" title="menu_dropdown_panel_styled.9.png">menu_dropdown_panel_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/progress_bg_styled.9.html" title="progress_bg_styled.9.png">progress_bg_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/progress_primary_styled.9.html" title="progress_primary_styled.9.png">progress_primary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/progress_secondary_styled.9.html" title="progress_secondary_styled.9.png">progress_secondary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/spinner_ab_default_styled.9.html" title="spinner_ab_default_styled.9.png">spinner_ab_default_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/spinner_ab_disabled_styled.9.html" title="spinner_ab_disabled_styled.9.png">spinner_ab_disabled_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/spinner_ab_focused_styled.9.html" title="spinner_ab_focused_styled.9.png">spinner_ab_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/spinner_ab_pressed_styled.9.html" title="spinner_ab_pressed_styled.9.png">spinner_ab_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tab_selected_focused_styled.9.html" title="tab_selected_focused_styled.9.png">tab_selected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tab_selected_pressed_styled.9.html" title="tab_selected_pressed_styled.9.png">tab_selected_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tab_selected_styled.9.html" title="tab_selected_styled.9.png">tab_selected_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tab_unselected_focused_styled.9.html" title="tab_unselected_focused_styled.9.png">tab_unselected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tab_unselected_pressed_styled.9.html" title="tab_unselected_pressed_styled.9.png">tab_unselected_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/Styled/res/drawable-mdpi/ab_bottom_solid_styled.9.html" title="ab_bottom_solid_styled.9.png">ab_bottom_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ab_solid_styled.9.html" title="ab_solid_styled.9.png">ab_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ab_stacked_solid_styled.9.html" title="ab_stacked_solid_styled.9.png">ab_stacked_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/list_focused_styled.9.html" title="list_focused_styled.9.png">list_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/menu_dropdown_panel_styled.9.html" title="menu_dropdown_panel_styled.9.png">menu_dropdown_panel_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/progress_bg_styled.9.html" title="progress_bg_styled.9.png">progress_bg_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/progress_primary_styled.9.html" title="progress_primary_styled.9.png">progress_primary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/progress_secondary_styled.9.html" title="progress_secondary_styled.9.png">progress_secondary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/spinner_ab_default_styled.9.html" title="spinner_ab_default_styled.9.png">spinner_ab_default_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/spinner_ab_disabled_styled.9.html" title="spinner_ab_disabled_styled.9.png">spinner_ab_disabled_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/spinner_ab_focused_styled.9.html" title="spinner_ab_focused_styled.9.png">spinner_ab_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/spinner_ab_pressed_styled.9.html" title="spinner_ab_pressed_styled.9.png">spinner_ab_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/tab_selected_focused_styled.9.html" title="tab_selected_focused_styled.9.png">tab_selected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/tab_selected_pressed_styled.9.html" title="tab_selected_pressed_styled.9.png">tab_selected_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/tab_selected_styled.9.html" title="tab_selected_styled.9.png">tab_selected_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/tab_unselected_focused_styled.9.html" title="tab_unselected_focused_styled.9.png">tab_unselected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-mdpi/tab_unselected_pressed_styled.9.html" title="tab_unselected_pressed_styled.9.png">tab_unselected_pressed_styled.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/Styled/res/drawable-xhdpi/ab_bottom_solid_styled.9.html" title="ab_bottom_solid_styled.9.png">ab_bottom_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ab_solid_styled.9.html" title="ab_solid_styled.9.png">ab_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ab_stacked_solid_styled.9.html" title="ab_stacked_solid_styled.9.png">ab_stacked_solid_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/list_focused_styled.9.html" title="list_focused_styled.9.png">list_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/menu_dropdown_panel_styled.9.html" title="menu_dropdown_panel_styled.9.png">menu_dropdown_panel_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/progress_bg_styled.9.html" title="progress_bg_styled.9.png">progress_bg_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/progress_primary_styled.9.html" title="progress_primary_styled.9.png">progress_primary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/progress_secondary_styled.9.html" title="progress_secondary_styled.9.png">progress_secondary_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/spinner_ab_default_styled.9.html" title="spinner_ab_default_styled.9.png">spinner_ab_default_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/spinner_ab_disabled_styled.9.html" title="spinner_ab_disabled_styled.9.png">spinner_ab_disabled_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/spinner_ab_focused_styled.9.html" title="spinner_ab_focused_styled.9.png">spinner_ab_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/spinner_ab_pressed_styled.9.html" title="spinner_ab_pressed_styled.9.png">spinner_ab_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/tab_selected_focused_styled.9.html" title="tab_selected_focused_styled.9.png">tab_selected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/tab_selected_pressed_styled.9.html" title="tab_selected_pressed_styled.9.png">tab_selected_pressed_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/tab_selected_styled.9.html" title="tab_selected_styled.9.png">tab_selected_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/tab_unselected_focused_styled.9.html" title="tab_unselected_focused_styled.9.png">tab_unselected_focused_styled.9.png</a></li><li><a href="/samples/Styled/res/drawable-xhdpi/tab_unselected_pressed_styled.9.html" title="tab_unselected_pressed_styled.9.png">tab_unselected_pressed_styled.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/Styled/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/Styled/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/Styled/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/Styled/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/Styled/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/Styled/res/values/colors.html" title="colors.xml">colors.xml</a></li><li><a href="/samples/Styled/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/Styled/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/Styled/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/Styled/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/Styled/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v14">values-v14/</a></div><ul><li><a href="/samples/Styled/res/values-v14/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.actionbarcompat.styled">com.example.android.actionbarcompat.styled/</a></div><ul><li><a href="/samples/Styled/src/com.example.android.actionbarcompat.styled/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/Basic/index.html" title="Basic">Basic</a></div><ul><li><a href="/samples/Basic/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/Basic/res/drawable-hdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Basic/res/drawable-hdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Basic/res/drawable-hdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Basic/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/Basic/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/Basic/res/drawable-mdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Basic/res/drawable-mdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Basic/res/drawable-mdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Basic/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/Basic/res/drawable-xhdpi/ic_action_location.html" title="ic_action_location.png">ic_action_location.png</a></li><li><a href="/samples/Basic/res/drawable-xhdpi/ic_action_refresh.html" title="ic_action_refresh.png">ic_action_refresh.png</a></li><li><a href="/samples/Basic/res/drawable-xhdpi/ic_action_settings.html" title="ic_action_settings.png">ic_action_settings.png</a></li><li><a href="/samples/Basic/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/Basic/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/Basic/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/Basic/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/Basic/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/Basic/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/Basic/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/Basic/res/values/ids.html" title="ids.xml">ids.xml</a></li><li><a href="/samples/Basic/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/Basic/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/Basic/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/Basic/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.actionbarcompat.basic">com.example.android.actionbarcompat.basic/</a></div><ul><li><a href="/samples/Basic/src/com.example.android.actionbarcompat.basic/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/ImmersiveMode/index.html" title="ImmersiveMode">ImmersiveMode</a></div><ul><li><a href="/samples/ImmersiveMode/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/ImmersiveMode/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ImmersiveMode/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/ImmersiveMode/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/ImmersiveMode/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/ImmersiveMode/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/ImmersiveMode/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/ImmersiveMode/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/ImmersiveMode/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/ImmersiveMode/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ImmersiveMode/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/ImmersiveMode/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/ImmersiveMode/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ImmersiveMode/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/ImmersiveMode/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.immersivemode">com.example.android.immersivemode/</a></div><ul><li><a href="/samples/ImmersiveMode/src/com.example.android.immersivemode/ImmersiveModeFragment.html" title="ImmersiveModeFragment.java">ImmersiveModeFragment.java</a></li><li><a href="/samples/ImmersiveMode/src/com.example.android.immersivemode/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/TextSwitcher/index.html" title="TextSwitcher">TextSwitcher</a></div><ul><li><a href="/samples/TextSwitcher/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/TextSwitcher/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/TextSwitcher/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/TextSwitcher/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/TextSwitcher/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/TextSwitcher/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/TextSwitcher/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/TextSwitcher/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/TextSwitcher/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/TextSwitcher/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/TextSwitcher/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/TextSwitcher/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/TextSwitcher/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/TextSwitcher/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/TextSwitcher/res/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v11">values-v11/</a></div><ul><li><a href="/samples/TextSwitcher/res/values-v11/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v14">values-v14/</a></div><ul><li><a href="/samples/TextSwitcher/res/values-v14/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/TextSwitcher/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.textswitcher">com.example.android.textswitcher/</a></div><ul><li><a href="/samples/TextSwitcher/src/com.example.android.textswitcher/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BorderlessButtons/index.html" title="BorderlessButtons">BorderlessButtons</a></div><ul><li><a href="/samples/BorderlessButtons/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BorderlessButtons/res/drawable-hdpi/ic_action_delete.html" title="ic_action_delete.png">ic_action_delete.png</a></li><li><a href="/samples/BorderlessButtons/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BorderlessButtons/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BorderlessButtons/res/drawable-mdpi/ic_action_delete.html" title="ic_action_delete.png">ic_action_delete.png</a></li><li><a href="/samples/BorderlessButtons/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BorderlessButtons/res/drawable-xhdpi/ic_action_delete.html" title="ic_action_delete.png">ic_action_delete.png</a></li><li><a href="/samples/BorderlessButtons/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BorderlessButtons/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BorderlessButtons/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BorderlessButtons/res/layout/list_item.html" title="list_item.xml">list_item.xml</a></li><li><a href="/samples/BorderlessButtons/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BorderlessButtons/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BorderlessButtons/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BorderlessButtons/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BorderlessButtons/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BorderlessButtons/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BorderlessButtons/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BorderlessButtons/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.borderlessbuttons">com.example.android.borderlessbuttons/</a></div><ul><li><a href="/samples/BorderlessButtons/src/com.example.android.borderlessbuttons/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BorderlessButtons/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicNotifications/index.html" title="BasicNotifications">BasicNotifications</a></div><ul><li><a href="/samples/BasicNotifications/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicNotifications/res/drawable-hdpi/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li><li><a href="/samples/BasicNotifications/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi-v11">drawable-hdpi-v11/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-hdpi-v11/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi-v9">drawable-hdpi-v9/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-hdpi-v9/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-ldpi-v11">drawable-ldpi-v11/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-ldpi-v11/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-ldpi-v9">drawable-ldpi-v9/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-ldpi-v9/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicNotifications/res/drawable-mdpi/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi-v11">drawable-mdpi-v11/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-mdpi-v11/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi-v9">drawable-mdpi-v9/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-mdpi-v9/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicNotifications/res/drawable-xhdpi/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi-v11">drawable-xhdpi-v11/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-xhdpi-v11/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi-v9">drawable-xhdpi-v9/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-xhdpi-v9/ic_stat_notification.html" title="ic_stat_notification.png">ic_stat_notification.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicNotifications/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicNotifications/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/BasicNotifications/res/layout/sample_layout.html" title="sample_layout.xml">sample_layout.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicNotifications/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicNotifications/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicNotifications/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicNotifications/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicNotifications/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicNotifications/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicnotifications">com.example.android.basicnotifications/</a></div><ul><li><a href="/samples/BasicNotifications/src/com.example.android.basicnotifications/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/AdvancedImmersiveMode/index.html" title="AdvancedImmersiveMode">AdvancedImmersiveMode</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/AdvancedImmersiveMode/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/AdvancedImmersiveMode/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/AdvancedImmersiveMode/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/AdvancedImmersiveMode/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/AdvancedImmersiveMode/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.advancedimmersivemode">com.example.android.advancedimmersivemode/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.advancedimmersivemode/AdvancedImmersiveModeFragment.html" title="AdvancedImmersiveModeFragment.java">AdvancedImmersiveModeFragment.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.advancedimmersivemode/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/AdvancedImmersiveMode/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/BasicImmersiveMode/index.html" title="BasicImmersiveMode">BasicImmersiveMode</a></div><ul><li><a href="/samples/BasicImmersiveMode/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/BasicImmersiveMode/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/menu/main.html" title="main.xml">main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/BasicImmersiveMode/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicImmersiveMode/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/BasicImmersiveMode/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/BasicImmersiveMode/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/BasicImmersiveMode/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.basicimmersivemode">com.example.android.basicimmersivemode/</a></div><ul><li><a href="/samples/BasicImmersiveMode/src/com.example.android.basicimmersivemode/BasicImmersiveModeFragment.html" title="BasicImmersiveModeFragment.java">BasicImmersiveModeFragment.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.basicimmersivemode/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common">com.example.android.common/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="activities">activities/</a></div><ul><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/activities/SampleActivityBase.html" title="SampleActivityBase.java">SampleActivityBase.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="logger">logger/</a></div><ul><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/BasicImmersiveMode/src/com.example.android.common/logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/CustomChoiceList/index.html" title="CustomChoiceList">CustomChoiceList</a></div><ul><li><a href="/samples/CustomChoiceList/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="color">color/</a></div><ul><li><a href="/samples/CustomChoiceList/res/color/hideable_text_color.html" title="hideable_text_color.xml">hideable_text_color.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable">drawable/</a></div><ul><li><a href="/samples/CustomChoiceList/res/drawable/ic_hideable_item.html" title="ic_hideable_item.xml">ic_hideable_item.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/CustomChoiceList/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/CustomChoiceList/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/CustomChoiceList/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/CustomChoiceList/res/drawable-xhdpi/ic_hideable_item_checked.html" title="ic_hideable_item_checked.png">ic_hideable_item_checked.png</a></li><li><a href="/samples/CustomChoiceList/res/drawable-xhdpi/ic_hideable_item_unchecked.html" title="ic_hideable_item_unchecked.png">ic_hideable_item_unchecked.png</a></li><li><a href="/samples/CustomChoiceList/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/CustomChoiceList/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/CustomChoiceList/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/CustomChoiceList/res/layout/list_item.html" title="list_item.xml">list_item.xml</a></li><li><a href="/samples/CustomChoiceList/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/CustomChoiceList/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/CustomChoiceList/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/CustomChoiceList/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/CustomChoiceList/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/CustomChoiceList/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.customchoicelist">com.example.android.customchoicelist/</a></div><ul><li><a href="/samples/CustomChoiceList/src/com.example.android.customchoicelist/CheckableLinearLayout.html" title="CheckableLinearLayout.java">CheckableLinearLayout.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.customchoicelist/Cheeses.html" title="Cheeses.java">Cheeses.java</a></li><li><a href="/samples/CustomChoiceList/src/com.example.android.customchoicelist/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/DoneBar/index.html" title="DoneBar">DoneBar</a></div><ul><li><a href="/samples/DoneBar/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/DoneBar/res/drawable-hdpi/ic_action_cancel.html" title="ic_action_cancel.png">ic_action_cancel.png</a></li><li><a href="/samples/DoneBar/res/drawable-hdpi/ic_action_done.html" title="ic_action_done.png">ic_action_done.png</a></li><li><a href="/samples/DoneBar/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/DoneBar/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/DoneBar/res/drawable-mdpi/ic_action_cancel.html" title="ic_action_cancel.png">ic_action_cancel.png</a></li><li><a href="/samples/DoneBar/res/drawable-mdpi/ic_action_done.html" title="ic_action_done.png">ic_action_done.png</a></li><li><a href="/samples/DoneBar/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/DoneBar/res/drawable-xhdpi/ic_action_cancel.html" title="ic_action_cancel.png">ic_action_cancel.png</a></li><li><a href="/samples/DoneBar/res/drawable-xhdpi/ic_action_done.html" title="ic_action_done.png">ic_action_done.png</a></li><li><a href="/samples/DoneBar/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/DoneBar/res/drawable-xhdpi/sample_dashboard_item_background.9.html" title="sample_dashboard_item_background.9.png">sample_dashboard_item_background.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/DoneBar/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/DoneBar/res/layout/actionbar_custom_view_done.html" title="actionbar_custom_view_done.xml">actionbar_custom_view_done.xml</a></li><li><a href="/samples/DoneBar/res/layout/actionbar_custom_view_done_cancel.html" title="actionbar_custom_view_done_cancel.xml">actionbar_custom_view_done_cancel.xml</a></li><li><a href="/samples/DoneBar/res/layout/activity_done_bar.html" title="activity_done_bar.xml">activity_done_bar.xml</a></li><li><a href="/samples/DoneBar/res/layout/activity_done_button.html" title="activity_done_button.xml">activity_done_button.xml</a></li><li><a href="/samples/DoneBar/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/DoneBar/res/layout/activity_sample_dashboard.html" title="activity_sample_dashboard.xml">activity_sample_dashboard.xml</a></li><li><a href="/samples/DoneBar/res/layout/include_cancel_button.html" title="include_cancel_button.xml">include_cancel_button.xml</a></li><li><a href="/samples/DoneBar/res/layout/include_done_button.html" title="include_done_button.xml">include_done_button.xml</a></li><li><a href="/samples/DoneBar/res/layout/sample_dashboard_item.html" title="sample_dashboard_item.xml">sample_dashboard_item.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/DoneBar/res/menu/cancel.html" title="cancel.xml">cancel.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/DoneBar/res/values/activitycards-strings.html" title="activitycards-strings.xml">activitycards-strings.xml</a></li><li><a href="/samples/DoneBar/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/DoneBar/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/DoneBar/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/DoneBar/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/DoneBar/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/DoneBar/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.donebar">com.example.android.donebar/</a></div><ul><li><a href="/samples/DoneBar/src/com.example.android.donebar/DoneBarActivity.html" title="DoneBarActivity.java">DoneBarActivity.java</a></li><li><a href="/samples/DoneBar/src/com.example.android.donebar/DoneButtonActivity.html" title="DoneButtonActivity.java">DoneButtonActivity.java</a></li><li><a href="/samples/DoneBar/src/com.example.android.donebar/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/ListPopupMenu/index.html" title="ListPopupMenu">ListPopupMenu</a></div><ul><li><a href="/samples/ListPopupMenu/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/ListPopupMenu/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ListPopupMenu/res/drawable-hdpi/ic_overflow.html" title="ic_overflow.png">ic_overflow.png</a></li><li><a href="/samples/ListPopupMenu/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/ListPopupMenu/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ListPopupMenu/res/drawable-mdpi/ic_overflow.html" title="ic_overflow.png">ic_overflow.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/ListPopupMenu/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/ListPopupMenu/res/drawable-xhdpi/ic_overflow.html" title="ic_overflow.png">ic_overflow.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/ListPopupMenu/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/ListPopupMenu/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/ListPopupMenu/res/layout/list_item.html" title="list_item.xml">list_item.xml</a></li><li><a href="/samples/ListPopupMenu/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="menu">menu/</a></div><ul><li><a href="/samples/ListPopupMenu/res/menu/popup.html" title="popup.xml">popup.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/ListPopupMenu/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/ListPopupMenu/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ListPopupMenu/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/ListPopupMenu/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/ListPopupMenu/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/ListPopupMenu/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.actionbarcompat.listpopupmenu">com.example.android.actionbarcompat.listpopupmenu/</a></div><ul><li><a href="/samples/ListPopupMenu/src/com.example.android.actionbarcompat.listpopupmenu/Cheeses.html" title="Cheeses.java">Cheeses.java</a></li><li><a href="/samples/ListPopupMenu/src/com.example.android.actionbarcompat.listpopupmenu/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li><li><a href="/samples/ListPopupMenu/src/com.example.android.actionbarcompat.listpopupmenu/PopupListFragment.html" title="PopupListFragment.java">PopupListFragment.java</a></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/CustomNotifications/index.html" title="CustomNotifications">CustomNotifications</a></div><ul><li><a href="/samples/CustomNotifications/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-hdpi/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi-v11">drawable-hdpi-v11/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-hdpi-v11/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi-v9">drawable-hdpi-v9/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-hdpi-v9/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-ldpi-v11">drawable-ldpi-v11/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-ldpi-v11/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-ldpi-v9">drawable-ldpi-v9/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-ldpi-v9/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-mdpi/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi-v11">drawable-mdpi-v11/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-mdpi-v11/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi-v9">drawable-mdpi-v9/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-mdpi-v9/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-xhdpi/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-xhdpi/robot.html" title="robot.png">robot.png</a></li><li><a href="/samples/CustomNotifications/res/drawable-xhdpi/robot_expanded.html" title="robot_expanded.png">robot_expanded.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi-v11">drawable-xhdpi-v11/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-xhdpi-v11/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi-v9">drawable-xhdpi-v9/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-xhdpi-v9/ic_stat_custom.html" title="ic_stat_custom.png">ic_stat_custom.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/CustomNotifications/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/CustomNotifications/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/CustomNotifications/res/layout/notification.html" title="notification.xml">notification.xml</a></li><li><a href="/samples/CustomNotifications/res/layout/notification_expanded.html" title="notification_expanded.xml">notification_expanded.xml</a></li><li><a href="/samples/CustomNotifications/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/CustomNotifications/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/CustomNotifications/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/CustomNotifications/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/CustomNotifications/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/CustomNotifications/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/CustomNotifications/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/CustomNotifications/res/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-v9">values-v9/</a></div><ul><li><a href="/samples/CustomNotifications/res/values-v9/styles.html" title="styles.xml">styles.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.customnotifications">com.example.android.customnotifications/</a></div><ul><li><a href="/samples/CustomNotifications/src/com.example.android.customnotifications/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li></ul></li><li class="nav-section"><div class="nav-section-header"><a href="/samples/views.html" title="Views">Views</a></div><ul><li class="nav-section"><div class="nav-section-header"><a href="/samples/TextLinkify/index.html" title="TextLinkify">TextLinkify</a></div><ul><li><a href="/samples/TextLinkify/AndroidManifest.html" title="AndroidManifest.xml">AndroidManifest.xml</a></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="res">res/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-hdpi">drawable-hdpi/</a></div><ul><li><a href="/samples/TextLinkify/res/drawable-hdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li><li><a href="/samples/TextLinkify/res/drawable-hdpi/tile.9.html" title="tile.9.png">tile.9.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-mdpi">drawable-mdpi/</a></div><ul><li><a href="/samples/TextLinkify/res/drawable-mdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xhdpi">drawable-xhdpi/</a></div><ul><li><a href="/samples/TextLinkify/res/drawable-xhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="drawable-xxhdpi">drawable-xxhdpi/</a></div><ul><li><a href="/samples/TextLinkify/res/drawable-xxhdpi/ic_launcher.html" title="ic_launcher.png">ic_launcher.png</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="layout">layout/</a></div><ul><li><a href="/samples/TextLinkify/res/layout/activity_main.html" title="activity_main.xml">activity_main.xml</a></li><li><a href="/samples/TextLinkify/res/layout/sample_main.html" title="sample_main.xml">sample_main.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values">values/</a></div><ul><li><a href="/samples/TextLinkify/res/values/base-strings.html" title="base-strings.xml">base-strings.xml</a></li><li><a href="/samples/TextLinkify/res/values/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/TextLinkify/res/values/strings.html" title="strings.xml">strings.xml</a></li><li><a href="/samples/TextLinkify/res/values/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw600dp">values-sw600dp/</a></div><ul><li><a href="/samples/TextLinkify/res/values-sw600dp/dimens.html" title="dimens.xml">dimens.xml</a></li><li><a href="/samples/TextLinkify/res/values-sw600dp/styles.html" title="styles.xml">styles.xml</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="values-sw720dp-land">values-sw720dp-land/</a></div><ul><li><a href="/samples/TextLinkify/res/values-sw720dp-land/dimens.html" title="dimens.xml">dimens.xml</a></li></ul></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="src">src/</a></div><ul><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.common.logger">com.example.android.common.logger/</a></div><ul><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/Log.html" title="Log.java">Log.java</a></li><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/LogFragment.html" title="LogFragment.java">LogFragment.java</a></li><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/LogNode.html" title="LogNode.java">LogNode.java</a></li><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/LogView.html" title="LogView.java">LogView.java</a></li><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/LogWrapper.html" title="LogWrapper.java">LogWrapper.java</a></li><li><a href="/samples/TextLinkify/src/com.example.android.common.logger/MessageOnlyLogFilter.html" title="MessageOnlyLogFilter.java">MessageOnlyLogFilter.java</a></li></ul></li><li class="nav-section sticky"><div class="nav-section-header empty"><a href="#" onclick="return false;" title="com.example.android.textlinkify">com.example.android.textlinkify/</a></div><ul><li><a href="/samples/TextLinkify/src/com.example.android.textlinkify/MainActivity.html" title="MainActivity.java">MainActivity.java</a></li></ul></li></ul></li></ul></li></ul></li></ul>
-
+  <?cs var:samples_toc_tree ?>
+ </ul>
diff --git a/docs/html/sdk/installing/studio.jd b/docs/html/sdk/installing/studio.jd
index d57d75b..f19e8bc 100644
--- a/docs/html/sdk/installing/studio.jd
+++ b/docs/html/sdk/installing/studio.jd
@@ -664,6 +664,7 @@
       $("#tos").hide();
       $("#main").show();
       location.hash = "Updating";
+      _gaq.push(['_trackEvent', 'SDK', 'Android Studio', $("#downloadForRealz").html()]);
       return true;
     } else {
       $("label#agreeLabel,#bitpicker input").parent().stop().animate({color: "#258AAF"}, 200,
diff --git a/docs/html/support.jd b/docs/html/support.jd
index 2f1222f..63bed30 100644
--- a/docs/html/support.jd
+++ b/docs/html/support.jd
@@ -1,5 +1,6 @@
 page.title=Developer Support
 fullpage=1
+excludeFromSuggestions=true
 @jd:body
 
 <div class="wrap" style="width:940px;">
@@ -16,6 +17,8 @@
 <h5>Community and Office Hours</h5>
 <p style="color:#888">
 
+<a href="https://plus.google.com/+AndroidDevelopers">Android Developers</a> on Google+<br />
+<a href="https://plus.google.com/communities/105153134372062985968">Android Development community</a> on Google+<br />
 <a href="http://groups.google.com/group/android-developers">android-developers</a> support forum<br />
 <a href="http://groups.google.com/group/android-ndk">android-ndk</a> support forum<br />
 <a href="http://groups.google.com/group/android-security-discuss">android-security-discuss</a> support forum<br />
@@ -71,4 +74,4 @@
 
 
 </div>
-</div>
\ No newline at end of file
+</div>
diff --git a/docs/html/tools/debugging/systrace.jd b/docs/html/tools/debugging/systrace.jd
index 287abe6..6472152 100644
--- a/docs/html/tools/debugging/systrace.jd
+++ b/docs/html/tools/debugging/systrace.jd
@@ -1,4 +1,5 @@
-page.title=Analyzing Display and Performance with Systrace
+page.title=Analyzing Display and Performance
+page.tags=systrace,speed
 parent.title=Debugging
 parent.link=index.html
 @jd:body
@@ -12,10 +13,11 @@
       <li><a href="#generate">Generating Traces</a>
         <ol>
           <li><a href="#limit-trace">Limiting trace data</a></li>
-          <li><a href="#config-categories">Configuring trace data categories</a></li>
-          <li><a href="#running">Running a trace</a></li>
+          <li><a href="#running-4.3">Tracing on Android 4.3 and higher</a>
+          <li><a href="#running-4.2">Tracing on Android 4.2 and lower</a></li>
         </ol>
       </li>
+      <li><a href="#app-trace">Tracing Application Code</a></li>
       <li><a href="#analysis">Analyzing Traces</a>
         <ol>
           <li><a href="#long-processes">Long running processes</a></li>
@@ -25,13 +27,12 @@
     </ol>
     <h2>See also</h2>
     <ol>
-      <li><a href="{@docRoot}tools/help/systrace.html">Systrace</a>
-      </li>
+      <li><a href="{@docRoot}tools/help/systrace.html">Systrace</a></li>
     </ol>
   </div>
 </div>
 
-<p>After building features, eliminating bugs and cleaning up your code, you should spend some
+<p>After building features, eliminating bugs, and cleaning up your code, you should spend some
   time looking at the performance of your application. The speed and smoothness with which your
   application draws pixels and performs operations has an significant impact on your users'
   experience.</p>
@@ -42,21 +43,21 @@
   threaded processes for resources, which can cause performance problems that are hard to diagnose.
 </p>
 
-<p>The {@code systrace} tool allows you to collect and review code execution data for your
+<p>The Systrace tool allows you to collect and review code execution data for your
   application and the Android system. You can use this data to diagnose execution problems and
   improve the performance of your application.</p>
 
 
 <h2 id="overview">Overview</h2>
 
-<p>{@code systrace} helps you analyze how the execution of your application fits into the larger
+<p>Systrace helps you analyze how the execution of your application fits into the larger
   Android environment, letting you see system and applications process execution on a common
   timeline. The tool allows you to generate highly detailed, interactive reports from devices
   running Android 4.1 and higher, such as the report in figure 1.</p>
 
 <img src="{@docRoot}images/systrace/report.png" alt="Systrace example report" id="figure1" />
 <p class="img-caption">
-  <strong>Figure 1.</strong> An example {@code systrace} report on 5 seconds of process execution
+  <strong>Figure 1.</strong> An example Systrace report on 5 seconds of process execution
   for a running application and related Android system processes.
 </p>
 
@@ -64,16 +65,21 @@
 <h2 id="generate">Generating Traces</h2>
 
 <p>In order to create a trace of your application, you must perform a few setup steps. First, you
-  must have a device running Android 4.1 or higher. Setup the device for
+  must have a device running Android 4.1 or higher. Set up the device for
   <a href="{@docRoot}tools/device.html#setting-up">debugging</a>, connect it to your development
-  system and install your application. Some types of trace information, specifically disk activity
-  and kernel work queues, require root access to the device, but most {@code systrace} log data
-  only requires that the device be enabled for developer debugging.</p>
+  system, and install your application. Some types of trace information, specifically disk activity
+  and kernel work queues, require that you have root access to the device. However, most Systrace
+  log data only requires that the device be enabled for developer debugging.</p>
+
+<p>Systrace traces can be run either from a
+  <a href="{@docRoot}tools/help/systrace.html#options">command line</a> or from a
+  <a href="{@docRoot}tools/help/systrace.html#gui">graphical user interface</a>. This guide
+  focuses on using the command line options.</p>
 
 
 <h3 id="limit-trace">Limiting trace data</h3>
 
-<p>The {@code systrace} tool can generate a potentially huge amount of data from applications
+<p>The Systrace tool can generate a potentially huge amount of data from applications
   and system sources. To limit the amount of data the tool collects and make the data more relevant
   to your analysis, use the following options:</p>
 
@@ -81,39 +87,68 @@
   <li>Limit the amount of time covered by the trace with the {@code -t, --time} option. The default
     length of a trace is 5 seconds.</li>
   <li>Limit the size of the data collected by the trace with the {@code -b, --buf-size} option.</li>
-  <li>Specify what types of processes are traced using the {@code --set-tags} option and the
-  {@code --disk}, {@code --cpu-freq}, {@code --cpu-idle}, {@code --cpu-load} options.</li>
+  <li>Specify what types of processes are traced. The types of processes that can be traced depends
+    on the version of Android you are running:
+    <ul>
+      <li>Android 4.2 and lower devices: Use the {@code --set-tags} option and the {@code --disk},
+        {@code --cpu-freq}, {@code --cpu-idle}, {@code --cpu-load} options.</li>
+      <li>Android 4.3 and higher devices: Use the {@code --list-categories} option to see what
+        categories are available on your test device.</li>
+    </ul>
+   </li>
 </ul>
 
 
-<h3 id="config-categories">Configuring trace data categories</h3>
+<h3 id="running-4.3">Tracing on Android 4.3 and higher</h3>
 
-<p>To use {@code systrace} effectively, you must specify the types of processes you want to trace.
+<p>To run a trace on Android 4.3 and higher devices:</p>
+
+<ol>
+  <li>Make sure the device is connected through a USB cable and is
+  <a href="{@docRoot}tools/device.html#setting-up">enabled for debugging</a>.</li>
+  <li>Run the trace with the options you want, for example:
+<pre>
+$ cd android-sdk/platform-tools/systrace
+$ python systrace.py --time=10 -o mynewtrace.html sched gfx view wm
+</pre>
+  </li>
+  <li>On the device, execute any user actions you want be included in the trace.</li>
+</ol>
+
+<p>For more information on the available options for running Systrace, see the
+<a href="{@docRoot}tools/help/systrace.html#options-4.3">Systrace</a> help page.</p>
+
+
+<h3 id="running-4.2">Tracing on Android 4.2 and lower</h3>
+
+<p>To use Systrace effectively with devices running Android 4.2 and lower,
+  you must configure the types of processes you want to trace before running a trace.
   The tool can gather the following types of process information:</p>
 
 <ul>
   <li>General system processes such as graphics, audio and input processes (selected using trace
-    <a href="{@docRoot}tools/help/systrace.html#tags">Tags</a>).</li>
+    <a href="{@docRoot}tools/help/systrace.html#tags">category tags</a>).</li>
   <li>Low level system information such as CPU, kernel and disk activity (selected using
-    <a href="{@docRoot}tools/help/systrace.html#options">Options</a>).</li>
+    <a href="{@docRoot}tools/help/systrace.html#options">options</a>).</li>
 </ul>
 
-<p>To set trace tags for {@code systrace} using the command-line:</p>
+<p>To set trace tags for Systrace using the command-line:</p>
 
 <ol>
   <li>Use the {@code --set-tags} option:
 <pre>
-$> python systrace.py --set-tags=gfx,view,wm
+$ cd android-sdk/platform-tools/systrace
+$ python systrace.py --set-tags=gfx,view,wm
 </pre>
   </li>
   <li>Stop and restart the {@code adb} shell to enable tracing of these processes.
 <pre>
-$> adb shell stop
-$> adb shell start
+$ adb shell stop
+$ adb shell start
 </pre></li>
 </ol>
 
-<p>To set trace tags for {@code systrace} using the device user interface:</p>
+<p>To set trace tags for Systrace using the device user interface:</p>
 
 <ol>
   <li>On the device connected for tracing, navigate to: <strong>Settings &gt;
@@ -126,9 +161,6 @@
   selecting trace tags using this method.
 </p>
 
-
-<h3 id="running">Running a trace</h3>
-
 <p>After you have configured the category tags for your trace, you can start collecting
   information for analysis.</p>
 
@@ -139,21 +171,77 @@
   <a href="{@docRoot}tools/device.html#setting-up">enabled for debugging</a>.</li>
   <li>Run the trace with the low-level system trace options and limits you want, for example:
 <pre>
-$> python systrace.py --cpu-freq --cpu-load --time=10 -o mytracefile.html
+$ python systrace.py --cpu-freq --cpu-load --time=10 -o mytracefile.html
 </pre>
   </li>
   <li>On the device, execute any user actions you want be included in the trace.</li>
 </ol>
 
+<p>For more information on the available options for running Systrace, see the
+<a href="{@docRoot}tools/help/systrace.html#options-pre-4.3">Systrace</a> help page.</p>
+
+
+<h2 id="app-trace">Tracing Application Code</h2>
+
+<p>The Systrace tool can trace the execution of code within your application. In Android
+4.3 (API level 18) and higher, you can use the methods of the {@link android.os.Trace} class to
+add instrumentation to your application code and see the results in a Systrace report.</p>
+
+<p>The following code example shows how to use the {@link android.os.Trace} class to track
+execution of an application method, including two nested code blocks within that method.</p>
+
+<pre>
+public void ProcessPeople() {
+    Trace.beginSection("ProcessPeople");
+    try {
+        Trace.beginSection("Processing Jane");
+        try {
+            // code for Jane task...
+        } finally {
+            Trace.endSection(); // ends "Processing Jane"
+        }
+
+        Trace.beginSection("Processing John");
+        try {
+            // code for John task...
+        } finally {
+            Trace.endSection(); // ends "Processing John"
+        }
+    } finally {
+        Trace.endSection(); // ends "ProcessPeople"
+    }
+}
+</pre>
+<p class="note">
+  <strong>Note:</strong> When you nest trace calls within each other, the
+  {@link android.os.Trace#endSection} method ends the most recently called
+  {@link android.os.Trace#beginSection} method. This means that a trace started within another
+  trace cannot extend beyond the end of the enclosing trace, so make sure your beginning and
+  ending method calls are properly matched to measure your applications processing.
+</p>
+
+<p class="note">
+  <strong>Note:</strong> Traces must begin and end on the same thread. Do not call
+  {@link android.os.Trace#beginSection} on one thread of execution and then attempt to end the
+  trace with a call to {@link android.os.Trace#endSection} on another thread.
+</p>
+
+<p>When using application-level tracing with Systrace, you must specify the package name of your
+application in the user interface or specify the {@code -a} or {@code --app=} options on the
+command line. For more information, see the
+<a href="{@docRoot}tools/help/systrace.html">Systrace</a> help page.</p>
+
+<!-- todo: add ndk coverage -->
+
 
 <h2 id="analysis">Analyzing Traces</h2>
 
-<p>After you have generated a trace using {@code systrace}, it lists the location of the output
+<p>After you have generated a trace using Systrace, it lists the location of the output
   file and you can open the report using a web browser.
   How you use the trace data depends on the performance issues you are investigating. However,
   this section provides some general instructions on how to analyze a trace.</p>
 
-<p>The reports generated by {@code systrace} are interactive, allowing you to zoom into and out of
+<p>The reports generated by Systrace are interactive, allowing you to zoom into and out of
   the process execution details. Use the <em>W</em> key to zoom in, the <em>S</em>
   key to zoom out, the <em>A</em> key to pan left and the <em>D</em> key to pan
   right. Select a task in timeline using your mouse to get more information about the task.
@@ -193,7 +281,7 @@
 
 <h3 id="display-interupts">Interruptions in display execution</h3>
 
-<p>The {@code systrace} tool is particularly useful in analyzing application display slowness,
+<p>The Systrace tool is particularly useful in analyzing application display slowness,
   or pauses in animations, because it shows you the execution of your application across multiple
   system processes. With display execution, drawing screen frames with a regular rhythm is essential
   for good performance. Having a regular rhythm for display ensures that animations and motion are
@@ -201,7 +289,7 @@
   from the users perspective.</p>
 
 <p>If you are analyzing an application for this type of problem, examine the
-  <strong>SurfaceFlinger</strong> process in the {@code systrace} report where your application is
+  <strong>SurfaceFlinger</strong> process in the Systrace report where your application is
   also executing to look for places where it drops out of its regular rhythm.</p>
 
 <img src="{@docRoot}images/systrace/display-rhythm.png" alt="Systrace exerpt of display processing"
@@ -231,9 +319,9 @@
 </p>
 
 <p class="note">
-  <strong>Note:</strong> When using {@code systrace} to analyze display problems, make sure
+  <strong>Note:</strong> When using Systrace to analyze display problems, make sure
   you activate the tracing tags for <strong>Graphics</strong> and <strong>Views</strong>.
 </p>
 
-<p>For more information on the command line options and keyboard controls for {@code systrace},
-see the <a href="{@docRoot}tools/help/systrace.html">Systrace</a> reference page.</p>
\ No newline at end of file
+<p>For more information on the command line options and keyboard controls for Systrace,
+see the <a href="{@docRoot}tools/help/systrace.html">Systrace</a> help page.</p>
\ No newline at end of file
diff --git a/docs/html/tools/help/monitor.jd b/docs/html/tools/help/monitor.jd
index e1fe772..513eb10 100644
--- a/docs/html/tools/help/monitor.jd
+++ b/docs/html/tools/help/monitor.jd
@@ -15,13 +15,14 @@
 
 <p>Android Device Monitor is a stand-alone tool that provides a graphical user interface for
 several Android application debugging and analysis tools. The Monitor tool does not
-require installation of a integrated development environment, such as Eclipse, and encapsulates the
+require installation of an integrated development environment, such as Eclipse, and encapsulates the
 following tools:</p>
 
 <ul>
   <li><a href="{@docRoot}tools/debugging/ddms.html">DDMS</a></li>
   <li><a href="gltracer.html">Tracer for OpenGL ES</a></li>
   <li><a href="hierarchy-viewer.html">Hierarchy Viewer</a></li>
+  <li><a href="systrace.html">Systrace</a></li>
   <li><a href="traceview.html">Traceview</a></li>
   <li>Pixel Perfect magnification viewer</li>
 </ul>
diff --git a/docs/html/tools/help/systrace.jd b/docs/html/tools/help/systrace.jd
index 010cc78..d6fc05e 100644
--- a/docs/html/tools/help/systrace.jd
+++ b/docs/html/tools/help/systrace.jd
@@ -4,47 +4,135 @@
 @jd:body
 
 
-<p>The {@code systrace} tool helps analyze the performance of your application by capturing and
+<p>The Systrace tool helps analyze the performance of your application by capturing and
   displaying execution times of your applications processes and other Android system processes. The
-  tool combines data from the Android kernel such as the CPU scheduler, disk activity and
+  tool combines data from the Android kernel such as the CPU scheduler, disk activity, and
   application threads to generate an HTML report that shows an overall picture of an Android
   device’s system processes for a given period of time.</p>
 
-<p>The {@code systrace} tool is particularly useful in diagnosing display problems where an
+<p>The Systrace tool is particularly useful in diagnosing display problems where an
   application is slow to draw or stutters while displaying motion or animation. For more information
-  on how to use {@code systrace}, see <a href="{@docRoot}tools/debugging/systrace.html">Analyzing
-  Display and Performance with Systrace</a>.</p>
+  on how to use Systrace, see <a href="{@docRoot}tools/debugging/systrace.html">Analyzing
+  Display and Performance</a>.</p>
 
 
-<h2 id="usage">Usage</h2>
 
-<p>In order to run {@code systrace}, the {@code adb} tool and
-<a href="http://www.python.org/">Python</a> must be installed and included in your development
+<h2 id="requirements">Requirements</h2>
+
+<p>In order to run Systrace, you must have Android SDK Tools 20 or later installed. You must also
+have <a href="http://www.python.org/">Python</a> installed and included in your development
 computer's execution path. In order to generate a trace, you must connect a device running Android
-4.1 (API Level 16) or higher to your development system using a USB debugging connection.</p>
+4.1 (API Level 16) or higher to your development system using a
+<a href="{@docRoot}tools/device.html#setting-up">USB debugging connection</a>.</p>
 
-<p>The syntax for running {@code systrace} is as follows.</p>
+<p>The Systrace tool can be run either from one of the Android SDK's graphical user interface
+tools, or from the command line. The following sections describe how to run the tool using either
+of these methods.</p>
+
+
+<h2 id="gui">User Interface</h2>
+
+<p>The Systrace tool can be run from the
+<a href="{@docRoot}tools/help/adt.html">Android Developer Tools</a> (ADT) in Eclipse,
+<a href="{@docRoot}sdk/installing/studio.html">Android Studio</a>,
+or the Android <a href="{@docRoot}tools/help/monitor.html">Device Monitor</a>.
+
+<p>To run the Systrace user interface:</p>
+
+<div class="toggle-content closed">
+<p style="margin-top:5px"><a href="#" onclick="return toggleContent(this)">
+  <img src="/assets/images/triangle-closed.png" class="toggle-content-img" alt=""
+  />Using Eclipse</a></p>
+
+  <div class="toggle-content-toggleme">
+  <ol>
+    <li>In Eclipse, open an Android application project.</li>
+    <li>Switch to the DDMS perspective, by selecting <strong>Window &gt; Perspectives &gt;
+      DDMS</strong>.</li>
+    <li>In the <strong>Devices</strong> tab, select the device on which to run a trace. If no
+      devices are listed, make sure your device is connected via USB cable and that debugging is
+      enabled on the device.</li>
+    <li>Click the Systrace icon <img src="{@docRoot}images/systrace/systrace-button.png"
+      style="margin:0"/> at the top of the <strong>Devices</strong> panel to configure tracing.</li>
+    <li>Set the tracing options and click <strong>OK</strong> to start the trace.</li>
+  </ol>
+  </div>
+</div>
+
+<div class="toggle-content closed">
+<p style="margin-top:5px"><a href="#" onclick="return toggleContent(this)">
+  <img src="/assets/images/triangle-closed.png" class="toggle-content-img" alt=""
+  />Using Android Studio</a></p>
+
+  <div class="toggle-content-toggleme">
+  <ol>
+    <li>In <a href="{@docRoot}sdk/installing/studio.html">Android Studio</a>, open an
+      Android application project.</li>
+    <li>Open the Device Monitor by selecting <strong>Tools &gt; Android &gt; Monitor</strong>.</li>
+    <li>In the <strong>Devices</strong> tab, select the device on which to run a trace. If no
+      devices are listed, make sure your device is connected via USB cable and that debugging is
+      enabled on the device.</li>
+    <li>Click the Systrace icon <img src="{@docRoot}images/systrace/systrace-button.png"
+      style="margin:0"/> at the top of the <strong>Devices</strong> panel to configure tracing.</li>
+    <li>Set the tracing options and click <strong>OK</strong> to start the trace.</li>
+  </ol>
+  </div>
+</div>
+
+<div class="toggle-content closed">
+<p style="margin-top:5px"><a href="#" onclick="return toggleContent(this)">
+  <img src="/assets/images/triangle-closed.png" class="toggle-content-img" alt=""
+  />Using Device Monitor</a></p>
+
+  <div class="toggle-content-toggleme">
+  <ol>
+    <li>Navigate to your SDK {@code tools/} directory.</li>
+    <li>Run the {@code monitor} program.</li>
+    <li>In the <strong>Devices</strong> tab, select the device on which to run a trace. If no
+      devices are listed, make sure your device is connected via USB cable and that debugging is
+      enabled on the device.</li>
+    <li>Click the Systrace icon <img src="{@docRoot}images/systrace/systrace-button.png"
+      style="margin:0"/> at the top of the <strong>Devices</strong> panel to configure tracing.</li>
+    <li>Set the tracing options and click <strong>OK</strong> to start the trace.</li>
+  </ol>
+  </div>
+</div>
+
+
+
+<h2 id="options">Command Line Usage</h2>
+
+<p>The Systrace tool has different command line options for devices running Android 4.3 (API
+level 18) and higher versus devices running Android 4.2 (API level 17) and lower. The following
+sections describe the different command line options for each version.</p>
+
+<p>The general syntax for running Systrace from the command line is as follows.</p>
 
 <pre>
-$> python systrace.py [options]
+$ python systrace.py [options] [category1] [category2] ... [categoryN]
 </pre>
 
-<p>Here is an example execution run that sets trace tags and generates a trace from a connected
-Android device.</p>
+<p>See the sections below for example Systrace sessions.</p>
+
+
+<h3 id="options-4.3">Android 4.3 and higher options</h3>
+
+<p>When you use Systrace on devices running Android 4.3 and higher, you must specify at least one
+trace category tag. Here is an example execution run that sets trace tags and generates a trace
+from a connected device.</p>
 
 <pre>
-$> cd <em>android-sdk</em>/tools/systrace
-$> python systrace.py --set-tags gfx,view,wm
-$> adb shell stop
-$> adb shell start
-$> python systrace.py --disk --time=10 -o mynewtrace.html
+$ cd <em>android-sdk</em>/platform-tools/systrace
+$ python systrace.py --time=10 -o mynewtrace.html sched gfx view wm
 </pre>
 
+<p class="note">
+  <strong>Tip:</strong> If you want to see the names of tasks in the trace output, you <em>must</em>
+  include the {@code sched} category in your command parameters.
+</p>
 
-
-<h2 id="options">Options</h2>
-
-<p>The table below lists the command line options for {@code systrace}.</p>
+<p>The table below lists the Systrace command line options for devices running Android 4.3
+(API level 18) and higher.</p>
 
 <table>
   <tr>
@@ -54,6 +142,12 @@
   </tr>
 
   <tr>
+    <td><nobr><code>-h, --help</code></nobr></td>
+
+    <td>Show the help message.</td>
+  </tr>
+
+  <tr>
     <td><code>-o&nbsp;&lt;<em>FILE</em>&gt;</code></td>
 
     <td>Write the HTML trace report to the specified file.</td>
@@ -62,14 +156,155 @@
   <tr>
     <td><code>-t N, --time=N</code></td>
 
-    <td>Trace activity for N seconds. Default value is 5 seconds.</td>
+    <td>Trace activity for <em>N</em> seconds. The default value is 5 seconds.</td>
   </tr>
 
   <tr>
     <td><code>-b N, --buf-size=N</code></td>
 
-    <td>Use a trace buffer size of N kilobytes. This option lets you limit the total size of the
-    data collected during a trace.</td>
+    <td>Use a trace buffer size of <em>N</em> kilobytes. This option lets you limit the total size
+    of the data collected during a trace.</td>
+  </tr>
+
+  <tr>
+    <td><code>-k&nbsp;&lt;<em>KFUNCS</em>&gt;<br>
+        --ktrace=&lt;<em>KFUNCS</em>&gt;</code></td>
+
+    <td>Trace the activity of specific kernel functions, specified in a comma-separated list.</td>
+  </tr>
+
+  <tr>
+    <td><code>-l, --list-categories</code></td>
+
+    <td>List the available tracing category tags. The available tags are:
+
+      <ul>
+        <li><code>gfx</code> - Graphics</li>
+        <li><code>input</code> - Input</li>
+        <li><code>view</code> - View</li>
+        <li><code>webview</code> - WebView</li>
+        <li><code>wm</code> - Window Manager</li>
+        <li><code>am</code> - Activity Manager</li>
+        <li><code>audio</code> - Audio</li>
+        <li><code>video</code> - Video</li>
+        <li><code>camera</code> - Camera</li>
+        <li><code>hal</code> - Hardware Modules</li>
+        <li><code>res</code> - Resource Loading</li>
+        <li><code>dalvik</code> - Dalvik VM</li>
+        <li><code>rs</code> - RenderScript</li>
+        <li><code>sched</code> - CPU Scheduling</li>
+        <li><code>freq</code> - CPU Frequency</li>
+        <li><code>membus</code> - Memory Bus Utilization</li>
+        <li><code>idle</code> - CPU Idle</li>
+        <li><code>disk</code> - Disk input and output</li>
+        <li><code>load</code> - CPU Load</li>
+        <li><code>sync</code> - Synchronization Manager</li>
+        <li><code>workq</code> - Kernel Workqueues</li>
+      </ul>
+
+      <p class="note"><strong>Note:</strong> Some trace categories are not supported on all
+      devices.</p>
+
+      <p class="note"><strong>Tip:</strong> If you want to see the names of tasks in the trace
+      output, you <em>must</em> include the {@code sched} category in your command parameters.</p>
+
+    </td>
+  </tr>
+
+  <tr>
+    <td><code>-a&nbsp;&lt;<em>APP_NAME</em>&gt;<br>
+        --app=&lt;<em>APP_NAME</em>&gt;</code></td>
+
+    <td>Enable tracing for applications, specified as a comma-separated list of
+    <a href="{@docRoot}guide/topics/manifest/manifest-element.html#package">package names</a>.
+    The apps must contain tracing instrumentation calls from the {@link android.os.Trace} class.
+    For more information, see <a href="{@docRoot}tools/debugging/systrace.html#app-trace">Analyzing
+    Display and Performance</a>.
+    </td>
+  </tr>
+
+
+
+  <tr>
+    <td><code>--link-assets</code></td>
+
+    <td>Link to the original CSS or JavaScript resources instead of embedding them in the HTML
+      trace report.</td>
+  </tr>
+
+  <tr>
+    <td><code>--from-file=&lt;<em>FROM_FILE</em>&gt;</code></td>
+
+    <td>Create the interactive Systrace report from a file, instead of running a live trace.</td>
+  </tr>
+
+  <tr>
+    <td><code>--asset-dir=&lt;<em>ASSET_DIR</em>&gt;</code></td>
+
+    <td>Specify a directory for the trace report assets. This option is useful for maintaining a
+      single set of assets for multiple Systrace reports.</td>
+  </tr>
+
+  <tr>
+    <td style="white-space:nowrap">
+    <code>-e &lt;<em>DEVICE_SERIAL</em>&gt;<br>
+    --serial=&lt;<em>DEVICE_SERIAL</em>&gt;</code></td>
+
+    <td>Conduct the trace on a specific connected device, identified by its
+      <a href="{@docRoot}tools/help/adb.html#devicestatus">device serial number</a>.</td>
+  </tr>
+
+</table>
+
+
+<h3 id="options-pre-4.3">Android 4.2 and lower options</h3>
+
+<p>Using Systrace on the command line with devices running Android 4.2 and lower is typically a
+two-step process. You must first set the trace tags you want to capture and then run the trace.
+Here is an example execution run that sets trace tags and generates a trace from a connected
+device.</p>
+
+<pre>
+$ cd <em>android-sdk</em>/platform-tools/systrace
+$ python systrace.py --set-tags gfx,view,wm
+$ adb shell stop
+$ adb shell start
+$ python systrace.py --disk --time=10 -o mynewtrace.html
+</pre>
+
+<p>The table below lists the Systrace command line options for devices running Android 4.2
+(API level 17) and lower.</p>
+
+<table>
+  <tr>
+    <th>Option</th>
+
+    <th>Description</th>
+  </tr>
+
+  <tr>
+    <td><nobr><code>-h, --help</code></nobr></td>
+
+    <td>Show the help message.</td>
+  </tr>
+
+  <tr>
+    <td><code>-o&nbsp;&lt;<em>FILE</em>&gt;</code></td>
+
+    <td>Write the HTML trace report to the specified file.</td>
+  </tr>
+
+  <tr>
+    <td><code>-t N, --time=N</code></td>
+
+    <td>Trace activity for <em>N</em> seconds. The default value is 5 seconds.</td>
+  </tr>
+
+  <tr>
+    <td><code>-b N, --buf-size=N</code></td>
+
+    <td>Use a trace buffer size of <em>N</em> kilobytes. This option lets you limit the total size
+    of the data collected during a trace.</td>
   </tr>
 
   <tr>
@@ -106,6 +341,12 @@
   </tr>
 
   <tr>
+    <td><nobr><code>-u, --bus-utilization</code></nobr></td>
+
+    <td>Trace the bus utilization levels. This option requires root access on the device.</td>
+  </tr>
+
+  <tr>
     <td><code>-w, --workqueue</code></td>
 
     <td>Trace kernel work queues. This option requires root access on the device.</td>
@@ -122,13 +363,13 @@
         <li><code>webview</code> - WebView</li>
         <li><code>wm</code> - Window Manager</li>
         <li><code>am</code> - Activity Manager</li>
-        <li><code>sync</code> - Sync Manager</li>
+        <li><code>sync</code> - Synchronization Manager</li>
         <li><code>audio</code> - Audio</li>
         <li><code>video</code> - Video</li>
         <li><code>camera</code> - Camera</li>
       </ul>
       <p class="note"><strong>Note:</strong> When setting trace tags from the command line, you
-      must stop and restart the framework ({@code $&gt; adb shell stop; adb shell start}) for the
+      must stop and restart the framework ({@code $ adb shell stop; adb shell start}) for the
       tag tracing changes to take effect.</p>
     </td>
   </tr>
@@ -140,22 +381,16 @@
     report.</td>
   </tr>
 
-  <tr>
-    <td><nobr><code>-h, --help</code></nobr></td>
-
-    <td>Show the help message.</td>
-  </tr>
-
 </table>
 
-<p>You can set the trace <a href="#tags">tags</a> for {@code systrace} with your device's user
-interface, by navigating to <strong>Settings &gt; Developer options &gt; Monitoring &gt; Enable
-traces</strong>.</p>
+<p>You can set the trace <a href="#tags">tags</a> for Systrace on
+your Android 4.2 and lower device by navigating to <strong>Settings &gt; Developer options &gt;
+Monitoring &gt; Enable traces</strong>.</p>
 
 
 <h2 id="viewing-options">Trace Viewing Shortcuts</h2>
 
-<p>The table below lists the keyboard shortcuts that are available while viewing a {@code systrace}
+<p>The table below lists the keyboard shortcuts that are available while viewing a Systrace
 trace HTML report.</p>
 
 <table>
diff --git a/docs/html/tools/revisions/build-tools.jd b/docs/html/tools/revisions/build-tools.jd
new file mode 100644
index 0000000..1da51b5
--- /dev/null
+++ b/docs/html/tools/revisions/build-tools.jd
@@ -0,0 +1,171 @@
+page.title=Build Tools
+@jd:body
+
+<div id="qv-wrapper">
+<div id="qv">
+
+  <h2>See Also</h2>
+  <ol>
+    <li><a href="{@docRoot}tools/building/index.html">Building and Running</a></li>
+  </ol>
+
+</div>
+</div>
+
+<p>Build Tools is a component of the Android SDK required for building Android
+  application code. The latest version of these tools is included in the
+  <a href="{@docRoot}sdk/index.html">SDK starter package</a> and installed in the
+  <code>&lt;sdk&gt;/build-tools/</code> directory.</p>
+
+<p>You should always keep your Build Tools component updated by downloading the latest version
+  using the <a href="{@docRoot}tools/help/sdk-manager.html">Android SDK Manager</a>. By default,
+  the Android SDK uses the most recent downloaded version of the Build Tools. If your projects
+  depend on older versions of the Build Tools, the SDK Manager allows you to download and maintain
+  separate versions of the tools for use with those projects.</p>
+
+<p>To use a specific version of the Build Tools in your application project:</p>
+
+<div class="toggle-content closed">
+<p style="margin-top:5px"><a href="#" onclick="return toggleContent(this)">
+  <img src="/assets/images/triangle-closed.png" class="toggle-content-img" alt=""
+  />Using Eclipse</a></p>
+
+  <div class="toggle-content-toggleme">
+  <ol>
+    <li>In the root folder of your application project, find the {@code project.properties}
+      file.</li>
+    <li>Open the file and specify the Build Tools version by adding a {@code buildtools} property
+      on a separate line:
+<pre>
+sdk.buildtools=17.0.0
+</pre>
+    </li>
+  </ol>
+  </div>
+</div>
+
+<div class="toggle-content closed">
+<p style="margin-top:5px"><a href="#" onclick="return toggleContent(this)">
+  <img src="/assets/images/triangle-closed.png" class="toggle-content-img" alt=""
+  />Using Android Studio</a></p>
+
+  <div class="toggle-content-toggleme">
+  <ol>
+    <li>In the root folder of your application project, find the {@code build.gradle}
+      file.</li>
+    <li>Open the file and specify the Build Tools version by adding a {@code buildToolsVersion}
+      property to the {@code android} section:
+<pre>
+android {
+    ...
+    buildToolsVersion "17.0.0"
+    ...
+}
+</pre>
+    </li>
+  </ol>
+  </div>
+</div>
+
+
+<h2 id="notes">Revisions</h2>
+
+<p>The sections below provide notes about releases of the Build Tools. To determine which
+revisions of the Build Tools are available in your SDK, refer to the <em>Installed Packages</em>
+listing in the Android SDK Manager.</p>
+
+
+<div class="toggle-content opened">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 19.0.1</a> <em>(December 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <dl>
+      <dt>Fixed miscellaneous build issues:</dt>
+      <dd>
+        <ul>
+          <li>Fixed support for compiling RenderScript in NDK mode with Gradle.</li>
+          <li>Fixed {@code BufferOverflowException} problem in the dx build.
+            (<a href="http://b.android.com/61710">Issue 61710</a>)
+          </li>
+        </ul>
+      </dd>
+    </dl>
+    <p></p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 19</a> <em>(October 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <p>Added support for Android 4.4 (API level 19) build targets.</p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 18.1.1</a> <em>(September 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <p>Fixed several minor build issues.</p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 18.1.0</a> <em>(September 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <p>Fixed issue with RenderScript support mode.</p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 18.0.1</a> <em>(July 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <p>Added support for Android 4.3 (API level 18) build targets.</p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img"
+      alt=""/>Build Tools, Revision 17</a> <em>(May 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+
+    <p>Initial release.</p>
+
+    <dl>
+      <dt>General Notes:</dt>
+      <dd>
+        <ul>
+          <li>Included support for Android 4.2 (API level 17) build targets.</li>
+          <li>Decoupled the build-specific components of the Android SDK from the platform-tools
+          component, so that the build tools can be updated independently of the integrated
+          development environment (IDE) components.</li>
+        </ul>
+      </dd>
+    </dl>
+
+  </div>
+</div>
diff --git a/docs/html/tools/revisions/platforms.jd b/docs/html/tools/revisions/platforms.jd
index f219784..c5d1ef6 100644
--- a/docs/html/tools/revisions/platforms.jd
+++ b/docs/html/tools/revisions/platforms.jd
@@ -7,14 +7,12 @@
 
 <h2>See Also</h2>
 <ol>
+  <li><a href="{@docRoot}about/versions/kitkat.html">KitKat
+Highlights and APIs</a></li>
   <li><a href="{@docRoot}about/versions/jelly-bean.html">Jelly Bean
 Highlights and APIs</a></li>
   <li><a href="{@docRoot}about/versions/android-4.0-highlights.html">Ice Cream Sandwich
 Highlights and APIs</a></li>
-  <li><a href="{@docRoot}about/versions/android-3.0-highlights.html">Honeycomb
-Highlights and APIs</a></li>
-  <li><a href="{@docRoot}about/versions/android-2.3-highlights.html">Gingerbread
-Highlights and APIs</a></li>
 </ol>
 
 </div>
@@ -52,11 +50,27 @@
 
 <h2 id="4.4">Android 4.4</h2>
 
-
 <div class="toggle-content opened">
-
   <p><a href="#" onclick="return toggleContent(this)">
     <img src="{@docRoot}assets/images/triangle-opened.png"
+class="toggle-content-img" alt="" />Revision 2</a> <em>(December 2013)</em>
+  </p>
+
+  <div class="toggle-content-toggleme">
+
+    <p>Maintenance release. The system version is 4.4.2.</p>
+    <dl>
+      <dt>Dependencies:</dt>
+      <dd>Android SDK Platform-tools r19 or higher is required.</dd>
+      <dd>Android SDK Tools 22.3 or higher is recommended.</dd>
+    </dl>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png"
 class="toggle-content-img" alt="" />Revision 1</a> <em>(October 2013)</em>
   </p>
 
@@ -72,19 +86,35 @@
   </div>
 </div>
 
+
 <h3 id="gsi-4.4">Google APIs System Image</h3>
 
 <div class="toggle-content opened">
   <p><a href="#" onclick="return toggleContent(this)">
     <img src="{@docRoot}assets/images/triangle-opened.png"
+class="toggle-content-img" alt="" />Revision 2</a> <em>(December 2013)</em>
+  </p>
+
+  <div class="toggle-content-toggleme">
+
+    <p>Maintenance release. This release includes
+    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 4.0.33,
+    allowing you to test your application in an emulator using the latest Google Play services.</p>
+
+  </div>
+</div>
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png"
 class="toggle-content-img" alt="" />Revision 1</a> <em>(October 2013)</em>
   </p>
 
   <div class="toggle-content-toggleme">
 
     <p>Initial release. This release includes
-    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 4.0.30,
-    allowing you to test your application in an emulator using the latest Google Play services.</p>
+    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 4.0.30.
+    </p>
 
   </div>
 </div>
@@ -143,8 +173,8 @@
   <div class="toggle-content-toggleme">
 
     <p>Maintenance update. This release includes
-    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 3.2.65,
-    allowing you to test your application in an emulator using the latest Google Play services.</p>
+    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 3.2.65.
+    </p>
 
   </div>
 </div>
@@ -158,8 +188,8 @@
   <div class="toggle-content-toggleme">
 
     <p>Maintenance update. This release includes
-    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 3.2.25,
-    allowing you to test your application in an emulator using the latest Google Play services.</p>
+    <a href="{@docRoot}google/play-services/index.html">Google Play services</a> version 3.2.25.
+    </p>
 
   </div>
 </div>
diff --git a/docs/html/tools/sdk/ndk/index.jd b/docs/html/tools/sdk/ndk/index.jd
index 87f8a87..4e50d98 100644
--- a/docs/html/tools/sdk/ndk/index.jd
+++ b/docs/html/tools/sdk/ndk/index.jd
@@ -1,58 +1,34 @@
 ndk=true
 page.template=sdk
 
-ndk.mac64.legacy_download=android-ndk-r9b-darwin-x86_64-legacy-toolchains.tar.bz2
-ndk.mac64.legacy_bytes=122378495
-ndk.mac64.legacy_checksum=19c696a5b690b040409c68b21e9fcf46
 
-ndk.mac64_download=android-ndk-r9b-darwin-x86_64.tar.bz2
-ndk.mac64_bytes=354748937
-ndk.mac64_checksum=710d80b6ff807f03e585f9aacee3bf09
+ndk.mac64_download=android-ndk-r9c-darwin-x86_64.tar.bz2
+ndk.mac64_bytes=358350393
+ndk.mac64_checksum=154bc0248671b8609037218d3faa47f5
 
+ndk.mac32_download=android-ndk-r9c-darwin-x86.tar.bz2
+ndk.mac32_bytes=352900444
+ndk.mac32_checksum=0ba391eb12d4eed6bd7dbff5d8804e0f
 
-ndk.mac32.legacy_download=android-ndk-r9b-darwin-x86-legacy-toolchains.tar.bz2
-ndk.mac32.legacy_bytes=119394536
-ndk.mac32.legacy_checksum=be0a07bcea3695f7d93cbd1b880d3f75
+ndk.linux64_download=android-ndk-r9c-linux-x86_64.tar.bz2
+ndk.linux64_bytes=371254928
+ndk.linux64_checksum=e9c3fd9881c811753bb57f701b3e05b1
 
-ndk.mac32_download=android-ndk-r9b-darwin-x86.tar.bz2
-ndk.mac32_bytes=349307548
-ndk.mac32_checksum=b5fa7aa3b9fca5a5b0c46bdd970d284b
+ndk.linux32_download=android-ndk-r9c-linux-x86.tar.bz2
+ndk.linux32_bytes=365412557
+ndk.linux32_checksum=93d2aa9a40501b568037642cdb174643
 
+ndk.win64_download=android-ndk-r9c-windows-x86_64.zip
+ndk.win64_bytes=483804820
+ndk.win64_checksum=9e84d0d59ce7d4a24370b619fb8799e4
 
-ndk.linux64.legacy_download=android-ndk-r9b-linux-x86_64-legacy-toolchains.tar.bz2
-ndk.linux64.legacy_bytes=127742633
-ndk.linux64.legacy_checksum=f41017d5888a8dc210d1703dcdf1def7
+ndk.win32_download=android-ndk-r9c-windows-x86.zip
+ndk.win32_bytes=460676475
+ndk.win32_checksum=863b5ab371b63c3e9bf0d39e47903763
 
-ndk.linux64_download=android-ndk-r9b-linux-x86_64.tar.bz2
-ndk.linux64_bytes=366988131
-ndk.linux64_checksum=56c0999a2683d6711591843217f943e0
-
-
-ndk.linux32.legacy_download=android-ndk-r9b-linux-x86-legacy-toolchains.tar.bz2
-ndk.linux32.legacy_bytes=125676842
-ndk.linux32.legacy_checksum=bfc7a1e6baf856b4348d57abffc761d2
-
-ndk.linux32_download=android-ndk-r9b-linux-x86.tar.bz2
-ndk.linux32_bytes=361394055
-ndk.linux32_checksum=d7f783deaeea6b60cb515d9427c01c2e
-
-
-ndk.win64.legacy_download=android-ndk-r9b-windows-x86_64-legacy-toolchains.zip
-ndk.win64.legacy_bytes=166961852
-ndk.win64.legacy_checksum=6eee9459986e8b7f1032d62831dd775b
-
-ndk.win64_download=android-ndk-r9b-windows-x86_64.zip
-ndk.win64_bytes=479012553
-ndk.win64_checksum=1ba6be7ebf4e9272d77031dd70f81e94
-
-
-ndk.win32.legacy_download=android-ndk-r9b-windows-x86-legacy-toolchains.zip
-ndk.win32.legacy_bytes=152568224
-ndk.win32.legacy_checksum=00c8373b53ad9475f1bab1de4219b877
-
-ndk.win32_download=android-ndk-r9b-windows-x86.zip
-ndk.win32_bytes=455928388
-ndk.win32_checksum=cfb9402ea08a1554186e85ed28cb4593
+ndk.debug_info_download=android-ndk-r9c-cxx-stl-libs-with-debugging-info.zip
+ndk.debug_info_bytes=100364569
+ndk.debug_info_checksum=37911716e1fd2fe3abb8a410750d73e6
 
 
 page.title=Android NDK
@@ -288,16 +264,87 @@
   contains legacy NDK toolchains for that platform, which is only required if you are not using
   the current, recommended toolchain for your NDK builds.</p>
 
-
-
 <h2 id="Revisions">Revisions</h2>
 
 <p>The following sections provide information about releases of the NDK.</p>
 
 <div class="toggle-content opened">
+ <p>
+   <a href="#" onclick="return toggleContent(this)"> <img
+     src="/assets/images/triangle-opened.png" class="toggle-content-img" alt=""
+   >Android NDK, Revision 9c</a> <em>(December 2013)</em>
+ </p>
+ <div class="toggle-content-toggleme">
+<p>This is a bug-fix-only release.</p>
+   <dl>
+     <dt>Important bug fixes:</dt>
+     <dd>
+     <ul>
+       <li>Fixed a problem with GCC 4.8 ARM, in which the stack pointer is restored too early. This problem prevented the frame pointer from reliably accessing a variable in the stack frame. For more information, see <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58854">http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58854</a>.</li>
+<li>- Fixed a problem with GCC 4.8 libstdc++, in which a bug in std::nth_element was causing generation of code that produced a random segfault. For more information, see <a href="https://code.google.com/p/android/issues/detail?id=62910">https://code.google.com/p/android/issues/detail?id=62910</a>.</li>
+           <li>Fixed GCC 4.8 ICE in cc1/cc1plus with <code>-fuse-ld=mcld</code>, so that the following error no longer occurs:
+<pre>cc1: internal compiler error: in common_handle_option, at opts.c:1774</pre></li>
+           <li>Fixed <code>-mhard-float</code> support for <code>__builtin</code> math functions. For ongoing information on fixes for -mhard-float with STL, please follow <a href="http://b.android.com/61784">http://b.android.com/61784</a>.</li>
+     </ul>
+     </dd>
+
+     <dt>Other bug fixes:</dt>
+     <dd>
+     <ul>
+       <li>Header fixes:
+         <ul>
+           <li>Changed prototype of <code>poll</code> to <code>poll(struct pollfd *, nfds_t, int);</code> in <code>poll.h</code>.</li>
+           <li>Added <code>utimensat</code> to <code>libc.so</code> in API levels 12 and 19. It is now present in levels 12-19.</li>
+<li>Introduced <code>futimens</code> into <code>libc.so</code>, as of API level 19.</li>
+<li>Added missing <code>clock_settime()</code> and <code>clock_nanosleep()</code> to <code>time.h</code> for API 8 and higher.</li>
+<li>Added <code>CLOCK_MONOTONIC_RAW, CLOCK_REALTIME_COARSE, CLOCK_MONOTONIC_COARSE, CLOCK_BOOTTIME, CLOCK_REALTIME_ALARM,</code> and <code>CLOCK_BOOTTIME_ALARM</code> in <code>time.h.</code></li>
+<li>Removed obsolete <code>CLOCK_REALTIME_HR</code> and <code>CLOCK_MONOTONIC_HR.</code></li>
+         </ul>
+       </li>
+       <li>Refactored samples Teapot, MoreTeapots, and <code>source/android/ndk_helper</code> as follows:
+         <ul>
+<li>They now use a hard-float abi for armeabi-v7a.</li>
+<li>Android-19 now has immersive mode.</li>
+<li>Fixed a problem with <code>Check_ReleaseStringUTFChars</code> in <code>/system/lib/libdvm.so</code> that was causing crashes on x86 devices.</li>
+         </ul>
+        </li>
+<li>Fixed ndk-build fails that happen in cygwin when the NDK package is referenced via symlink.</li>
+<li>Fixed ndk-build.cmd fails that happen in windows <code>cmd.exe</code> when <code>LOCAL_SRC_FILES</code> contains absolute paths. See <a href="https://android-review.googlesource.com/#/c/69992">https://android-review.googlesource.com/#/c/69992.</a></li>
+<li>Fixed ndk-stack to proceed even when it can't parse a frame due to inability to find a routine, filename, or line number. In any of those cases, it prints "??".</li>
+<li>Fixed ndk-stack windows-x64_64 so that it no longer erroneously matches a frame line with a line in the <code>stack:</code>
+  section that doesn't contain <code>pc</code>, <code>eip</code>, or <code>ip</code>. For example:
+<pre>I/DEBUG   ( 1151):     #00  5f09db68  401f01c4  /system/lib/libc.so</pre></li>
+<li>Fixed gabi++ so that it:
+     <ul>
+         <li>Does not use malloc() to allocate C++ thread-local
+  objects.</li>
+         <li>Avoids deadlocks in gabi++ in cases where libc.debug.malloc is non-zero in
+  userdebug/eng Android platform builds.</li>
+     </ul>
+     </ul>
+     </dd>
+
+     <dt>Other changes:</dt>
+     <dd>
+     <ul>
+       <li>Added <code>LOCAL_EXPORT_LDFLAGS</code>.</li>
+<li>Introduced the <code>NDK_PROJECT_PATH=null</code> setting for use in an integrated build system where options are explicitly passed to <code>ndk-build</code>. With this setting, <code>ndk-build</code> makes no attempt to look for <code>NDK_PROJECT_PATH.</code> This setting also prevents variables from deriving default settings from NDK_PROJECT_PATH. As a result, the following variables must now be explicitly specified (with their default values if such exist): <code>NDK_OUT, NDK_LIBS_OUT, APP_BUILD_SCRIPT, NDK_DEBUG</code> (optional, default to 0), and other <code>APP_*</code>'s contained in <code>Application.mk</code>.</li>
+<li><code>APP_ABI</code> can now be enumerated in a comma-delimited list. For example:
+<pre>APP_ABI := "armeabi,armeabi-v7a"</pre></li>
+<li>Provided the ability (option <code>-g</code>) to rebuild all of STL with debugging info in an optional, separate package called <code>android-ndk-r9c-cxx-stl-libs-with-debugging-info.zip</code>. This option helps ndk-stack to provide better a stack dump across STL. This change should not affect the code/size of the final, stripped file.</li>
+<li>Enhanced <code>hello-jni</code> samples to report <code>APP_ABI</code> at compilation.</li>
+<li>Used the <code>ar</code> tool in Deterministic mode (option <code>-D</code>) to build static libraries.  For more information, see <a href="http://b.android.com/60705">http://b.android.com/60705</a>.</li>
+     </ul>
+     </dd>
+
+   </dl>
+ </div>
+</div>
+
+<div class="toggle-content closed">
   <p>
     <a href="#" onclick="return toggleContent(this)"> <img
-      src="{@docRoot}assets/images/triangle-opened.png" class="toggle-content-img" alt=""
+      src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" alt=""
     >Android NDK, Revision 9b</a> <em>(October 2013)</em>
   </p>
   <div class="toggle-content-toggleme">
diff --git a/docs/html/tools/sdk/preview/features.jd b/docs/html/tools/sdk/preview/features.jd
index 02897cd..2bdb0f4 100644
--- a/docs/html/tools/sdk/preview/features.jd
+++ b/docs/html/tools/sdk/preview/features.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 @jd:body
 
 <script type="text/javascript">
diff --git a/docs/html/tools/sdk/preview/index.jd b/docs/html/tools/sdk/preview/index.jd
index d96df93..713730e 100644
--- a/docs/html/tools/sdk/preview/index.jd
+++ b/docs/html/tools/sdk/preview/index.jd
@@ -1,3 +1,4 @@
 sdk.redirect=true
 page.template=sdk
+excludeFromSuggestions=true
 @jd:body
diff --git a/docs/html/tools/sdk/preview/installing.jd b/docs/html/tools/sdk/preview/installing.jd
index c40e531..d248b67 100644
--- a/docs/html/tools/sdk/preview/installing.jd
+++ b/docs/html/tools/sdk/preview/installing.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 @jd:body
 
 <script type="text/javascript">
diff --git a/docs/html/tools/sdk/preview/requirements.jd b/docs/html/tools/sdk/preview/requirements.jd
index b5aed80..b62ee05 100644
--- a/docs/html/tools/sdk/preview/requirements.jd
+++ b/docs/html/tools/sdk/preview/requirements.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 @jd:body
 
 <script type="text/javascript">
diff --git a/docs/html/tools/sdk/preview/upgrading.jd b/docs/html/tools/sdk/preview/upgrading.jd
index 1c53bdb..3b90696 100644
--- a/docs/html/tools/sdk/preview/upgrading.jd
+++ b/docs/html/tools/sdk/preview/upgrading.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 @jd:body
 
 <script type="text/javascript">
diff --git a/docs/html/tools/support-library/index.jd b/docs/html/tools/support-library/index.jd
index dba4e74..389238f 100644
--- a/docs/html/tools/support-library/index.jd
+++ b/docs/html/tools/support-library/index.jd
@@ -62,6 +62,49 @@
 <div class="toggle-content opened">
   <p><a href="#" onclick="return toggleContent(this)">
     <img src="{@docRoot}assets/images/triangle-opened.png" class="toggle-content-img" alt=""
+/>Android Support Library, revision 19.0.1</a> <em>(December 2013)</em>
+  </p>
+  <div class="toggle-content-toggleme">
+    <dl>
+      <dt>Changes for v4 support library:</dt>
+      <dd>
+        <ul>
+          <li>Improved {@link android.support.v4.print.PrintHelper} by adding asynchronous
+            handling of printing.</li>
+          <li>Fixed the {@link android.support.v4.widget.DrawerLayout} class approximation of
+            the {@link android.view.View#addChildrenForAccessibility addChildrenForAccessibility()}
+            method.</li>
+          <li>Fixed slide drawable mirroring in {@link
+            android.support.v4.app.ActionBarDrawerToggle}.</li>
+          <li>Fixed off-by-one issue when removing an item from a collection iterator.</li>
+        </ul>
+      </dd>
+
+      <dt>Changes for v7 mediarouter library:</dt>
+      <dd>
+        <ul>
+          <li>Improved route identification by using full component name in the {@link
+            android.support.v7.media.MediaRouteProvider.ProviderMetadata}.</li>
+          <li>Updated {@link android.support.v7.app.MediaRouteChooserDialog} to hide disabled
+            routes.</li>
+        </ul>
+      </dd>
+
+      <dt>Changes for v8 renderscript library:</dt>
+      <dd>
+        <ul>
+          <li>Added error propagation for the RenderScript thunking layer.</li>
+        </ul>
+      </dd>
+
+    </dl>
+  </div>
+</div>
+
+
+<div class="toggle-content closed">
+  <p><a href="#" onclick="return toggleContent(this)">
+    <img src="{@docRoot}assets/images/triangle-closed.png" class="toggle-content-img" alt=""
 />Android Support Library, revision 19</a> <em>(October 2013)</em>
   </p>
   <div class="toggle-content-toggleme">
diff --git a/docs/html/tools/tools_toc.cs b/docs/html/tools/tools_toc.cs
index 39eecf8..3e6b6d4 100644
--- a/docs/html/tools/tools_toc.cs
+++ b/docs/html/tools/tools_toc.cs
@@ -138,7 +138,7 @@
       <li><a href="<?cs var:toroot ?>tools/debugging/improving-w-lint.html"><span class="en">Improving Your Code with lint</span></a></li>
       <li><a href="<?cs var:toroot ?>tools/debugging/debugging-ui.html"><span class="en">Optimizing your UI</span></a></li>
       <li><a href="<?cs var:toroot ?>tools/debugging/debugging-tracing.html"><span class="en">Profiling with Traceview and dmtracedump</span></a></li>
-      <li><a href="<?cs var:toroot ?>tools/debugging/systrace.html"><span class="en">Analysing Display and Performance with Systrace</span></a></li>
+      <li><a href="<?cs var:toroot ?>tools/debugging/systrace.html"><span class="en">Analyzing Display and Performance</span></a></li>
       <li><a href="<?cs var:toroot ?>tools/debugging/debugging-memory.html">Investigating Your RAM Usage</a></li>
       <li><a href="<?cs var:toroot ?>tools/debugging/debugging-devtools.html"><span class="en">Using the Dev Tools App</span></a></li>
     </ul>
@@ -225,14 +225,14 @@
 ?>tools/revisions/index.html"><span class="en">Revisions</span></a></div>
     <ul>
       <li><a href="<?cs var:toroot ?>tools/sdk/tools-notes.html">
-        <span class="en">Tools</span>
+        <span class="en">SDK Tools</span>
       </a></li>
       <li><a href="<?cs var:toroot ?>tools/sdk/eclipse-adt.html">
         <span class="en">ADT Plugin</span>
       </a></li>
-      <!--
-      <li><a href="<?cs var:toroot ?>tools/sdk/addons.html"><span class="en">Add-ons</span></a></li>
-      -->
+      <li><a href="<?cs var:toroot ?>tools/revisions/build-tools.html">
+        <span class="en">Build Tools</span>
+      </a></li>
       <li><a href="<?cs var:toroot ?>tools/revisions/platforms.html"><span
 class="en">Platforms</span></a></li>
     </ul>
diff --git a/docs/html/training/app-indexing/deep-linking.jd b/docs/html/training/app-indexing/deep-linking.jd
new file mode 100644
index 0000000..a52ae95
--- /dev/null
+++ b/docs/html/training/app-indexing/deep-linking.jd
@@ -0,0 +1,134 @@
+page.title=Enabling Deep Links for App Content
+trainingnavtop=true
+
+@jd:body
+
+<!-- This is the training bar -->
+<div id="tb-wrapper">
+<div id="tb">
+
+<h2>This lesson teaches you to</h2>
+<ol>
+  <li><a href="#adding-filters">Add Intent Filters for Your Deep Links</a></li>
+  <li><a href="#handling-intents">Read Data from Incoming Intents</a></li>
+  <li><a href="#testing-filters">Test Your Deep Links</a></li>
+</ol>
+
+<h2>You should also read</h2>
+<ul>
+<li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent Filters</a></li>
+<li><a href="{@docRoot}training/basics/intents/filters.html">Allow Other Apps to Start Your Activity</a></li>
+</ul>
+
+</div>
+</div>
+
+<p>To enable Google to crawl your app content and allow users to enter your app
+  from search results, you must add intent filters for the relevant
+  activities in your app manifest. These intent filters allow
+  <em>deep linking</em> to the content in any of your activities. For example, the user might click on a deep link to view a page within a shopping app that describes a product offering that the user is searching for.</p>
+
+<h2 id="adding-filters">Add Intent Filters for Your Deep Links</h2>
+<p>To create a deep link to your app content, add an intent filter that
+  contains these elements and attribute values in your manifest:</p>
+<dl>
+<dt><a href="{@docRoot}guide/topics/manifest/action-element.html">{@code &lt;action&gt;}</a></dt>
+<dd>Specify the {@link android.content.Intent#ACTION_VIEW} intent action so
+  that the intent filter can be reached from Google Search.</dd>
+<dt><a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a></dt>
+<dd>Add one or more <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> tags, where each tag represents a URI format that resolves to the activity. At minimum, the <a href="{@docRoot}guide/topics/manifest/data-element.html">{@code &lt;data&gt;}</a> tag must include the <a href="{@docRoot}guide/topics/manifest/data-element.html#scheme">{@code android:scheme}</a> attribute.
+<p>You can add additional attributes to further refine the type of URI that the activity accepts. For example, you might have multiple activities that accept similar URIs, but which differ simply based on the path name. In this case, use the <a href="{@docRoot}guide/topics/manifest/data-element.html#path">{@code android:path}</a> attribute or its variants ({@code pathPattern} or {@code pathPrefix}) to differentiate which activity the system should open for different URI paths.</p></dd>
+<dt><a href="{@docRoot}guide/topics/manifest/category-element.html">{@code &lt;category&gt;}</a></dt>
+<dd>Include the {@link android.content.Intent#CATEGORY_BROWSABLE BROWSABLE}
+category. The {@link android.content.Intent#CATEGORY_BROWSABLE BROWSABLE}
+category is required in order for the intent filter to be accessible from a web
+browser. Without it, clicking a link in a browser cannot resolve to your app.
+The {@link android.content.Intent#CATEGORY_DEFAULT DEFAULT} category is
+optional, but recommended. Without this category, the activity can be started
+only with an explicit intent, using your app component name.
+</dd>
+</dl>
+
+<p>The following XML snippet shows how you might specify an intent filter
+in your manifest for deep linking. The URIs {@code “example://gizmos”} and
+{@code “http://www.example.com/gizmos”} both resolve to this activity.</p>
+
+<pre>
+&lt;activity
+    android:name="com.example.android.GizmosActivity"
+    android:label="@string/title_gizmos" &gt;
+    &lt;intent-filter android:label="@string/filter_title_viewgizmos"&gt;
+        &lt;action android:name="android.intent.action.VIEW" /&gt;
+        &lt;category android:name="android.intent.category.DEFAULT" /&gt;
+        &lt;category android:name="android.intent.category.BROWSABLE" /&gt;
+        &lt;!-- Accepts URIs that begin with "example://gizmos” --&gt;
+        &lt;data android:scheme="example"
+              android:host="gizmos" /&gt;
+        &lt;!-- Accepts URIs that begin with "http://www.example.com/gizmos” --&gt;
+        &lt;data android:scheme="http"
+              android:host="www.example.com"
+              android:pathPrefix="gizmos" /&gt;
+    &lt;/intent-filter&gt;
+&lt;/activity&gt;
+</pre>
+
+<p>Once you've added intent filters with URIs for activity content to your app
+manifest, Android is able to route any {@link android.content.Intent}
+that has matching URIs to your app at runtime.</p>
+
+<p>To learn more about defining intent filters, see <a href="{@docRoot}training/basics/intents/filters.html">Allow Other Apps to Start Your Activity</a>.</p>
+
+<h2 id="handling-intents">Read Data from Incoming Intents</h2>
+<p>Once the system starts your activity through an intent filter, you can
+  use data provided by the {@link android.content.Intent} to determine what you need to render. Call the {@link android.content.Intent#getData()} and
+{@link android.content.Intent#getAction()} methods to retrieve the data and
+action associated with the incoming {@link android.content.Intent}. You can
+call these methods at any time during the lifecycle of the activity, but you
+should generally do so during early callbacks such as {@link
+android.app.Activity#onCreate(android.os.Bundle) onCreate()} or
+{@link android.app.Activity#onStart()}.</p>
+<p>Here’s a snippet that shows how to retrieve data from an
+{@link android.content.Intent}:</p>
+<pre>
+&#64;Override
+public void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.main);
+
+    Intent intent = getIntent();
+    String action = intent.getAction();
+    Uri data = intent.getData();
+}
+</pre>
+<p>Follow these best practices to improve the user's experience:</p>
+<ul>
+<li>The deep link should take users directly to the content,
+without any prompts, interstitial pages, or logins. Make sure that users can
+see the app content even if they never previously opened the application.
+It is okay to prompt users on subsequent interactions or when they open the app
+from the Launcher. This is the same principle as the <a href="https://support.google.com/webmasters/answer/74536?hl=en" class="external-link" target="_blank">first click free</a> experience for web sites.</li>
+<li>Follow the design guidance described in
+  <a href="{@docRoot}design/patterns/navigation.html">Navigation with Back and Up</a>
+  so that your app matches users' expectations for backward navigation after
+  they enter your app through a deep link.
+</li>
+</ul>
+
+<h2 id="testing-filters">Test Your Deep Links</h2>
+<p>You can use the <a href="{@docRoot}tools/help/adb.html">Android Debug
+Bridge</a> with the activity manager (am) tool to test that the intent filter
+URIs you specified for deep linking resolve to the correct app activity. You
+can run the adb command against a device or an emulator.</p>
+<p>The general syntax for testing an intent filter URI with adb is:</p>
+<pre>
+$ adb shell am start
+        -W -a android.intent.action.VIEW
+        -d &lt;URI&gt; &lt;PACKAGE&gt;
+</pre>
+<p>For example, the command below tries to view a target app activity that
+is associated with the specified URI.</p>
+<pre>
+$ adb shell am start
+        -W -a android.intent.action.VIEW
+        -d "example://gizmos" com.example.android
+</pre>
diff --git a/docs/html/training/app-indexing/enabling-app-indexing.jd b/docs/html/training/app-indexing/enabling-app-indexing.jd
new file mode 100644
index 0000000..1636bbc
--- /dev/null
+++ b/docs/html/training/app-indexing/enabling-app-indexing.jd
@@ -0,0 +1,115 @@
+page.title=Specifying App Content for Indexing
+trainingnavtop=true
+
+@jd:body
+
+<!-- This is the training bar -->
+<div id="tb-wrapper">
+<div id="tb">
+
+<h2>This lesson teaches you to</h2>
+<ol>
+  <li><a href="#sitemap">Add Deep Links in Your Sitemap</a></li>
+  <li><a href="#webpages">Add Deep Links in Your Web Pages</a></li>
+  <li><a href="#robots">Allow Google to Crawl URLs Requested By Your App</a></li>
+</ol>
+
+<h2>You should also read</h2>
+<ul>
+<li><a href="https://www.google.com/webmasters/tools/home?hl=en" class="external-link" target="_blank">Webmaster Tools</a></li>
+<li><a href="https://support.google.com/webmasters/answer/183668" class="external-link" target="_blank">Creating Sitemaps</a></li>
+<li><a href="https://support.google.com/webmasters/answer/182072?hl=en" class="external-link" target="_blank">Googlebot</a></li>
+</ul>
+</div>
+</div>
+
+<p>Google's web crawling bot (<a href="https://support.google.com/webmasters/answer/182072?hl=en" class="external-link" target="_blank">Googlebot</a>), which crawls and indexes web sites
+for the Google search engine, can also index content in your Android app.
+By opting in, you can allow Googlebot to crawl the content in the APK
+through the Google Play Store to index the app content. To indicate which app
+content you’d like Google to index, simply add link elements either to
+your existing <a href="https://support.google.com/webmasters/answer/156184?hl=en" class="external-link" target="_blank">Sitemap</a> file or in the {@code &lt;head&gt;} element of each web
+page in your site, in the same way as you would for web pages.</p>
+<p class="note"><strong>Note: </strong>
+Currently, the Google Search app indexing capability is restricted to
+English-only Android apps from developers participating in the early adopter
+program. You can sign up to be a participant by submitting the <a
+href="https://docs.google.com/a/google.com/forms/d/1itcqPAQqggJ6e4m8aejWLM8Dc5O8P6qybgGbKCNxGV0/viewform"
+class="external-link" target="_blank">App Indexing Expression of Interest</a> form.
+</p>
+
+<p>The deep links that you share with Google Search must take this URI
+format:</p>
+<pre>
+android-app://&lt;package_name&gt;/&lt;scheme&gt;/&lt;host_path&gt;
+</pre>
+<p>The components that make up the URI format are:</p>
+<ul>
+<li><strong>package_name.</strong> Represents the package name for your APK as
+listed in the <a href="https://play.google.com/apps/publish" class="external-link" target="_blank">Google Play Developer Console</a>.</li>
+<li><strong>scheme.</strong> The URI scheme that matches your intent filter.</li>
+<li><strong>host_path.</strong> Identifies the specific content within your application.
+</li>
+</ul>
+<p>The following sections describe how to add a deep link URI to your Sitemap
+or web pages.</p>
+<h2 id="sitemap">Add Deep Links in Your Sitemap</h2>
+<p>To annotate the deep link for Google Search app indexing in your
+<a href="https://support.google.com/webmasters/answer/156184?hl=en" class="external-link" target="_blank">Sitemap</a>, use the
+{@code &lt;xhtml:link&gt;} tag and specify the deep link as an alternate URI.</p>
+<p>For example, the following XML snippet shows how you might specify a link to
+your web page by using the {@code &lt;loc&gt;} tag, and a corresponding deep
+link to your Android app by using the {@code &lt;xhtml:link&gt;} tag.</p>
+<pre>
+&lt;?xml version="1.0" encoding="UTF-8" ?&gt;
+&lt;urlset
+    xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+    xmlns:xhtml="http://www.w3.org/1999/xhtml"&gt;
+    &lt;url&gt;
+        &lt;loc&gt;example://gizmos&lt;/loc&gt;
+            &lt;xhtml:link
+                rel="alternate"
+                href="android-app://com.example.android/example/gizmos" /&gt;
+    &lt;/url&gt;
+    ...
+&lt;/urlset&gt;
+</pre>
+<h2 id="webpages">Add Deep Links in Your Web Pages</h2>
+<p>Instead of specifying the deep links for Google Search app indexing in your
+Sitemap file, you can annotate the deep links in the HTML markup of your web
+pages. You can do this in the {@code &lt;head&gt;} section for each web
+page by adding a {@code &lt;link&gt;} tag and specifying the deep link as an
+alternate URI.</p>
+<p>For example, the following HTML snippet shows how you might specify the
+corresponding deep link in a web page that has the URL
+{@code example://gizmos}.</p>
+<pre>
+&lt;html&gt;
+&lt;head&gt;
+    &lt;link rel="alternate"
+          href="android-app://com.example.android/example/gizmos" /&gt;
+    ...
+&lt;/head&gt;
+&lt;body&gt; ... &lt;/body&gt;
+</pre>
+
+<h2 id="robots">Allow Google to Crawl URLs Requested By Your App</h2>
+<p>Typically, you control how Googlebot crawls publicly accessible URLs on
+	your site by using a <a href="https://developers.google.com/webmasters/control-crawl-index/docs/robots_txt" class="external-link" target="_blank">{@code robots.txt}</a>
+file. When Googlebot indexes your app content, your app might make HTTP
+requests as part of its normal operations. However, these requests will
+appear to your servers as originating from Googlebot. Therefore, you must
+configure your server's {@code robots.txt} file properly to allow these
+requests.</p>
+<p>For example, the following {@code robots.txt} directive shows how you might
+allow access to a specific directory in your web site (for example,
+{@code /api/}) that your app needs to access, while restricting Googlebot's
+access to other parts of your site.</p>
+<pre>
+User-Agent: Googlebot
+Allow: /api/
+Disallow: /
+</pre>
+<p>To learn more about how to modify {@code robots.txt} to control web
+crawling, see the <a href="https://developers.google.com/webmasters/control-crawl-index/docs/getting_started" class="external-link" target="_blank">Controlling Crawling
+and Indexing Getting Started</a> guide.</p>
diff --git a/docs/html/training/app-indexing/index.jd b/docs/html/training/app-indexing/index.jd
new file mode 100644
index 0000000..6965ce5
--- /dev/null
+++ b/docs/html/training/app-indexing/index.jd
@@ -0,0 +1,89 @@
+page.title=Making Your App Searchable
+page.tags="app indexing"
+
+trainingnavtop=true
+startpage=true
+
+@jd:body
+
+<div id="tb-wrapper">
+<div id="tb">
+
+<h2>Dependencies and prerequisites</h2>
+<ul>
+  <li>Android 2.3 (API level 9) and higher</li>
+</ul>
+
+<h2>You Should Also Read</h2>
+<ul>
+<li><a href="http://insidesearch.blogspot.com/2013/12/the-power-of-search-now-across-apps.html" class="external-link" target="_blank">The power of Search, now across apps (blog post)</a></li>
+<li><a href="https://developers.google.com/app-indexing/" class="external-link"
+target="_blank">App Indexing for Google Search</a></li>
+<li><a href="{@docRoot}guide/components/intents-filters.html">Intents and Intent
+Filters</a></li>
+</ul>
+</div>
+</div>
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=Xh_W82JgOms">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: App Indexing</p>
+</div>
+</a>
+
+<p>As mobile apps become more pervasive, users are looking for relevant
+information not only from web sites but also from apps they have installed.
+You can enable Google to crawl through your app content and present your
+Android app as a destination to users through Google Search results, when
+that content corresponds to a web page that you own.</p>
+
+<p>You can make it possible for Google Search to open specific content in your
+  app by providing intent filters for your activities. Google Search
+app indexing complements this capability by presenting links to relevant app
+content alongside links to your web pages in users' search results. Users on
+mobile devices can then click on a link to open your app from their search
+results, allowing them to directly view your app's content instead of a
+web page.</p>
+
+<p>To enable Google Search app indexing, you need to provide Google with
+information about the relationship between your app and web site. This process
+involves the following steps:</p>
+<ol>
+<li>Enable deep linking to specific content
+in your app by adding intent filters in your app manifest.</li>
+<li>Annotate these links in the associated web pages on your web site or in a
+	Sitemap file.</li>
+<li>Opt in to allow Googlebot to crawl through your APK in the Google Play store
+	to index your app content. You are automatically opted-in when you join as
+	a participant in the early adopter program.
+</li>
+</ol>
+
+<p class="note"><strong>Note: </strong>
+Currently, the Google Search app indexing capability is restricted to
+English-only Android apps from developers participating in the early adopter
+program. You can sign up to be a participant by submitting the <a
+href="https://docs.google.com/a/google.com/forms/d/1itcqPAQqggJ6e4m8aejWLM8Dc5O8P6qybgGbKCNxGV0/viewform"
+class="external-link" target="_blank">App Indexing Expression of Interest</a> form.
+</p>
+
+<p>This class shows how to enable deep linking and indexing of your application
+content so that users can open this content directly from mobile search
+results.</p>
+
+<h2>Lessons</h2>
+
+<!-- Create a list of the lessons in this class along with a short description of each lesson.
+These should be short and to the point. It should be clear from reading the summary whether someone
+will want to jump to a lesson or not.-->
+
+<dl>
+  <dt><b><a href="deep-linking.html">Enabling Deep Links for App
+Content</a></b></dt>
+    <dd>Shows how to add intent filters to enable deep linking to app
+content.</dd>
+  <dt><b><a href="enabling-app-indexing.html">Specifying  App Content for
+Indexing</a></b></dt>
+    <dd>Shows how to annotate web site metadata to allow Google's algorithms to index
+app content.</dd>
+</dl>
diff --git a/docs/html/training/basics/intents/filters.jd b/docs/html/training/basics/intents/filters.jd
index 9b6a111..10bf43d 100644
--- a/docs/html/training/basics/intents/filters.jd
+++ b/docs/html/training/basics/intents/filters.jd
@@ -148,8 +148,8 @@
 {@link android.content.Intent#CATEGORY_DEFAULT} category in the intent filter. The methods {@link
 android.app.Activity#startActivity startActivity()} and {@link
 android.app.Activity#startActivityForResult startActivityForResult()} treat all intents as if they
-contained the {@link android.content.Intent#CATEGORY_DEFAULT} category. If you do not declare it, no
-implicit intents will resolve to your activity.</p>
+declared the {@link android.content.Intent#CATEGORY_DEFAULT} category. If you do not declare it
+in your intent filter, no implicit intents will resolve to your activity.</p>
 
 <p>For more information about sending and receiving {@link android.content.Intent#ACTION_SEND}
 intents that perform social sharing behaviors, see the lesson about <a
diff --git a/docs/html/training/basics/intents/sending.jd b/docs/html/training/basics/intents/sending.jd
index 79c017b..30dc95a 100644
--- a/docs/html/training/basics/intents/sending.jd
+++ b/docs/html/training/basics/intents/sending.jd
@@ -241,9 +241,13 @@
 // Always use string resources for UI text.
 // This says something like "Share this photo with"
 String title = getResources().getString(R.string.chooser_title);
-// Create and start the chooser
+// Create intent to show chooser
 Intent chooser = Intent.createChooser(intent, title);
-startActivity(chooser);
+
+// Verify the intent will resolve to at least one activity
+if (intent.resolveActivity(getPackageManager()) != null) {
+    startActivity(chooser);
+}
 </pre>
 
 <p>This displays a dialog with a list of apps that respond to the intent passed to the {@link
diff --git a/docs/html/training/connect-devices-wirelessly/index.jd b/docs/html/training/connect-devices-wirelessly/index.jd
index db79abe..aada1fd 100644
--- a/docs/html/training/connect-devices-wirelessly/index.jd
+++ b/docs/html/training/connect-devices-wirelessly/index.jd
@@ -20,9 +20,15 @@
   <li><a href="{@docRoot}guide/topics/connectivity/wifip2p.html">Wi-Fi P2P</a></li>
 </ul>
 
+</div>
+</div>
 
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=oi_ARV_I8Dc">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Network Service Discovery</p>
 </div>
-</div>
+</a>
 
 
 <p>Besides enabling communication with the cloud, Android's wireless APIs also
diff --git a/docs/html/training/displaying-bitmaps/index.jd b/docs/html/training/displaying-bitmaps/index.jd
index 1f44fa8..fba9fc5 100644
--- a/docs/html/training/displaying-bitmaps/index.jd
+++ b/docs/html/training/displaying-bitmaps/index.jd
@@ -25,6 +25,20 @@
 </div>
 </div>
 
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=rsQet4nBVi8">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Bitmap Allocation</p>
+</div>
+</a>
+
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=pMRnGDR6Cu0">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Making Apps Beautiful - Part 4 - Performance Tuning</p>
+</div>
+</a>
+
 <p>Learn how to use common techniques to process and load {@link
 android.graphics.Bitmap} objects in a way that keeps your user interface (UI) components responsive
 and avoids exceeding your application memory limit. If you're not careful, bitmaps can quickly
diff --git a/docs/html/training/improving-layouts/index.jd b/docs/html/training/improving-layouts/index.jd
index af29d3f..8cb2258 100644
--- a/docs/html/training/improving-layouts/index.jd
+++ b/docs/html/training/improving-layouts/index.jd
@@ -26,6 +26,13 @@
 </div>
 </div>
 
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=-FUw8HMbmBQ">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Optimising Layouts with Hierarchy Viewer</p>
+</div>
+</a>
+
 
 
 <p>Layouts are a key part of Android applications that directly affect the user experience. If
diff --git a/docs/html/training/notepad/index.jd b/docs/html/training/notepad/index.jd
index 64ba144..d1aa221 100644
--- a/docs/html/training/notepad/index.jd
+++ b/docs/html/training/notepad/index.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 page.title=Notepad Tutorial
 parent.title=Tutorials
 @jd:body
diff --git a/docs/html/training/notepad/notepad-ex1.jd b/docs/html/training/notepad/notepad-ex1.jd
index 0decbb2..f680f15 100644
--- a/docs/html/training/notepad/notepad-ex1.jd
+++ b/docs/html/training/notepad/notepad-ex1.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 page.title=Notepad Exercise 1
 parent.title=Notepad Tutorial
 parent.link=index.html
diff --git a/docs/html/training/notepad/notepad-ex2.jd b/docs/html/training/notepad/notepad-ex2.jd
index 895a071..d15499b3 100644
--- a/docs/html/training/notepad/notepad-ex2.jd
+++ b/docs/html/training/notepad/notepad-ex2.jd
@@ -1,4 +1,5 @@
-Rpage.title=Notepad Exercise 2
+excludeFromSuggestions=true
+page.title=Notepad Exercise 2
 parent.title=Notepad Tutorial
 parent.link=index.html
 @jd:body
diff --git a/docs/html/training/notepad/notepad-ex3.jd b/docs/html/training/notepad/notepad-ex3.jd
index e31ecda..648f9f2 100644
--- a/docs/html/training/notepad/notepad-ex3.jd
+++ b/docs/html/training/notepad/notepad-ex3.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 page.title=Notepad Exercise 3
 parent.title=Notepad Tutorial
 parent.link=index.html
diff --git a/docs/html/training/notepad/notepad-extra-credit.jd b/docs/html/training/notepad/notepad-extra-credit.jd
index d5fd771..8ab2021 100644
--- a/docs/html/training/notepad/notepad-extra-credit.jd
+++ b/docs/html/training/notepad/notepad-extra-credit.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 page.title=Notepad Extra Credit
 parent.title=Notepad Tutorial
 parent.link=index.html
diff --git a/docs/html/training/notepad/notepad-index.jd b/docs/html/training/notepad/notepad-index.jd
index 151c50d..fde43fa 100644
--- a/docs/html/training/notepad/notepad-index.jd
+++ b/docs/html/training/notepad/notepad-index.jd
@@ -1,3 +1,4 @@
+excludeFromSuggestions=true
 page.title=Notepad Tutorial
 @jd:body
 
diff --git a/docs/html/training/printing/index.jd b/docs/html/training/printing/index.jd
index 7b67b74..8161b6b 100644
--- a/docs/html/training/printing/index.jd
+++ b/docs/html/training/printing/index.jd
@@ -17,6 +17,13 @@
   </div>
 </div>
 
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=Iub67ic87KI">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Android 4.4 Printing API</p>
+</div>
+</a>
+
 <p>
   Android users frequently view content solely on their devices, but there are times when
   showing someone a screen is not an adequate way to share information. Being able to print
diff --git a/docs/html/training/sharing/send.jd b/docs/html/training/sharing/send.jd
index f5da68f..e869d5f 100644
--- a/docs/html/training/sharing/send.jd
+++ b/docs/html/training/sharing/send.jd
@@ -75,10 +75,12 @@
 <p>If there's an installed application with a filter that matches
 {@link android.content.Intent#ACTION_SEND} and MIME type text/plain, the Android system will run
 it; if more than one application matches, the system displays a disambiguation dialog (a "chooser")
-that allows the user to choose an app. If you call
+that allows the user to choose an app.</p>
+
+<p>However, if you call
 {@link android.content.Intent#createChooser(android.content.Intent, CharSequence)
-Intent.createChooser()}
-for the intent, Android will <strong>always</strong> display the chooser. This has some
+Intent.createChooser()}, passing it your {@link android.content.Intent} object, it returns a version
+of your intent that will <strong>always display the chooser</strong>. This has some
 advantages:</p>
 
 <ul>
@@ -102,10 +104,8 @@
 
 <p>Optionally, you can set some standard extras for the intent:
 {@link android.content.Intent#EXTRA_EMAIL}, {@link android.content.Intent#EXTRA_CC},
-{@link android.content.Intent#EXTRA_BCC}, {@link android.content.Intent#EXTRA_SUBJECT}. However,
-if the receiving application is not designed to use them, nothing will happen. You can use
-custom extras as well, but there's no effect unless the receiving application understands them.
-Typically, you'd use custom extras defined by the receiving application itself.</p>
+{@link android.content.Intent#EXTRA_BCC}, {@link android.content.Intent#EXTRA_SUBJECT}.
+If the receiving application is not designed to use them, it simply ignores them.</p>
 
 <p class="note"><strong>Note:</strong> Some e-mail applications, such as Gmail, expect a
 {@link java.lang.String String[]} for extras like {@link android.content.Intent#EXTRA_EMAIL} and
diff --git a/docs/html/training/system-ui/immersive.jd b/docs/html/training/system-ui/immersive.jd
index 21672c8..0a1516c 100644
--- a/docs/html/training/system-ui/immersive.jd
+++ b/docs/html/training/system-ui/immersive.jd
@@ -11,8 +11,8 @@
 <h2>This lesson teaches you to</h2>
 <ol>
   <li><a href="#compare">Choose an Approach</a></li>
-  <li><a href="#nonsticky">Use IMMERSIVE</a></li>
-  <li><a href="#sticky">Use IMMERSIVE_STICKY</a></li>
+  <li><a href="#nonsticky">Use Non-Sticky Immersion</a></li>
+  <li><a href="#sticky">Use Sticky Immersion</a></li>
 </ol>
 
 
@@ -72,14 +72,6 @@
 shown in this mode are in a transient state.
 </p>
 
- <p>When you use {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE IMMERSIVE} or
- {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE_STICKY IMMERSIVE_STICKY},
- the system UI stays hidden, even while users are interacting with your
-app or game. You can capture touch events from anywhere across the screen, even areas that
-would otherwise be occupied by the system bars. This gives you a great way to create a
-larger, richer, more <a href="{@docRoot}design/patterns/fullscreen.html">
-immersive</a> UI in your app or game and reduce visual distraction at the same time.</p>
-
 <p>Figure 1 illustrates the different "immersive mode" states:</p>
 
  <img src="{@docRoot}images/training/imm-states.png"
@@ -137,12 +129,8 @@
 
  <p>The flags  {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE} and
  {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE_STICKY} both provide an immersive
- experience. But whereas the
- {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE_STICKY IMMERSIVE_STICKY}
- flag causes semi-transparent system bars to briefly show and then hide again in response to
- a swipe gesture, the same swipe gesture causes the system bars to reappear and remain
- visible if you instead use the {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE IMMERSIVE}
- flag. Here are examples of when you would use one vs. the other:</p>
+ experience, but with the differences in behavior described above. Here are
+ examples of when you would use one flag vs. the other:</p>
 
 <ul>
 <li>If you're building a book reader, news reader, or a magazine, use
@@ -171,7 +159,7 @@
 sufficient. Don't use the "immersive" flags in this case.</li>
 </ul>
 
-<h2 id="nonsticky">Use IMMERSIVE</h2>
+<h2 id="nonsticky">Use Non-Sticky Immersion</h2>
 
  <p>When you use the {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE} flag, it hides
  the system bars based on what other UI flags you have set
@@ -242,7 +230,7 @@
 <a class ="external-link" href="http://www.youtube.com/embed/cBi8fjv90E4">DevBytes:
  Android 4.4 Immersive Mode</a>.</p>
 
-<h2 id="sticky">Use IMMERSIVE_STICKY</h2>
+<h2 id="sticky">Use Sticky Immersion</h2>
 
 <p>When you use the {@link android.view.View#SYSTEM_UI_FLAG_IMMERSIVE_STICKY} flag,
 an inward swipe in the system bars areas causes the bars to temporarily appear in a
diff --git a/docs/html/training/training_toc.cs b/docs/html/training/training_toc.cs
index 1314c7a..d28f37b 100644
--- a/docs/html/training/training_toc.cs
+++ b/docs/html/training/training_toc.cs
@@ -1001,6 +1001,27 @@
         </ul>
       </li>
 
+     <li class="nav-section">
+        <div class="nav-section-header">
+          <a href="<?cs var:toroot ?>training/app-indexing/index.html"
+             description=
+             "How to enable deep linking and indexing of your application
+content so that users can open this content directly from their mobile search
+results."
+            >Making Your App Content Searchable</a>
+        </div>
+        <ul>
+          <li><a href="<?cs var:toroot ?>training/app-indexing/deep-linking.html">
+            Enabling Deep Links for App Content
+          </a>
+          </li>
+          <li><a href="<?cs var:toroot ?>training/app-indexing/enabling-app-indexing.html">
+            Specifying  App Content for Indexing
+          </a>
+          </li>
+        </ul>
+      </li>
+
     </ul>
   </li>
   <!-- End best UX and UI -->
diff --git a/docs/html/training/tv/index.jd b/docs/html/training/tv/index.jd
index 9d15f46..54f7016 100644
--- a/docs/html/training/tv/index.jd
+++ b/docs/html/training/tv/index.jd
@@ -17,6 +17,14 @@
 
 </div>
 </div>
+
+<a class="notice-developers-video wide" href="http://www.youtube.com/watch?v=zsRnRLh-O34">
+<div>
+    <h3>Video</h3>
+    <p>DevBytes: Design for Large Displays - Part 1</p>
+</div>
+</a>
+
 <p> 
   Smart TVs powered by Android bring your favorite Android apps to the best screen in your house. 
   Thousands of apps in the Google Play Store are already optimized for TVs. This class shows how 
@@ -48,4 +56,4 @@
   <dt><b><a href="unsupported-features-tv.html">Handling features not supported on TV</a></b></dt>
     <dd>Lists the hardware features that are usually not available on TVs. This lesson also shows you how to 
     provide alternatives for missing features or check for missing features and disable code at run time.</dd>
-</dl> 
\ No newline at end of file
+</dl> 
diff --git a/graphics/java/android/graphics/ColorMatrix.java b/graphics/java/android/graphics/ColorMatrix.java
index c22cda1..e3596c8 100644
--- a/graphics/java/android/graphics/ColorMatrix.java
+++ b/graphics/java/android/graphics/ColorMatrix.java
@@ -19,7 +19,7 @@
 import android.util.FloatMath;
 
 /**
- *  5x4 matrix for transforming the color+alpha components of a Bitmap.
+ *  4x5 matrix for transforming the color+alpha components of a Bitmap.
  *  The matrix is stored in a single array, and its treated as follows:
  *  [ a, b, c, d, e,
  *    f, g, h, i, j,
diff --git a/media/java/android/media/MediaRouter.java b/media/java/android/media/MediaRouter.java
index 525dc4f..de20227 100644
--- a/media/java/android/media/MediaRouter.java
+++ b/media/java/android/media/MediaRouter.java
@@ -61,9 +61,6 @@
     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
 
     static class Static implements DisplayManager.DisplayListener {
-        // Time between wifi display scans when actively scanning in milliseconds.
-        private static final int WIFI_DISPLAY_SCAN_INTERVAL = 10000;
-
         final Context mAppContext;
         final Resources mResources;
         final IAudioService mAudioService;
@@ -87,6 +84,7 @@
 
         final boolean mCanConfigureWifiDisplays;
         boolean mActivelyScanningWifiDisplays;
+        String mPreviousActiveWifiDisplayAddress;
 
         int mDiscoveryRequestRouteTypes;
         boolean mDiscoverRequestActiveScan;
@@ -106,16 +104,6 @@
             }
         };
 
-        final Runnable mScanWifiDisplays = new Runnable() {
-            @Override
-            public void run() {
-                if (mActivelyScanningWifiDisplays) {
-                    mDisplayService.scanWifiDisplays();
-                    mHandler.postDelayed(this, WIFI_DISPLAY_SCAN_INTERVAL);
-                }
-            }
-        };
-
         Static(Context appContext) {
             mAppContext = appContext;
             mResources = Resources.getSystem();
@@ -279,15 +267,24 @@
             }
 
             // Update wifi display scanning.
-            if (activeScanWifiDisplay && mCanConfigureWifiDisplays) {
-                if (!mActivelyScanningWifiDisplays) {
-                    mActivelyScanningWifiDisplays = true;
-                    mHandler.post(mScanWifiDisplays);
+            // TODO: All of this should be managed by the media router service.
+            if (mCanConfigureWifiDisplays) {
+                if (mSelectedRoute != null
+                        && mSelectedRoute.matchesTypes(ROUTE_TYPE_REMOTE_DISPLAY)) {
+                    // Don't scan while already connected to a remote display since
+                    // it may interfere with the ongoing transmission.
+                    activeScanWifiDisplay = false;
                 }
-            } else {
-                if (mActivelyScanningWifiDisplays) {
-                    mActivelyScanningWifiDisplays = false;
-                    mHandler.removeCallbacks(mScanWifiDisplays);
+                if (activeScanWifiDisplay) {
+                    if (!mActivelyScanningWifiDisplays) {
+                        mActivelyScanningWifiDisplays = true;
+                        mDisplayService.startWifiDisplayScan();
+                    }
+                } else {
+                    if (mActivelyScanningWifiDisplays) {
+                        mActivelyScanningWifiDisplays = false;
+                        mDisplayService.stopWifiDisplayScan();
+                    }
                 }
             }
 
@@ -945,6 +942,9 @@
             }
             dispatchRouteSelected(types & route.getSupportedTypes(), route);
         }
+
+        // The behavior of active scans may depend on the currently selected route.
+        sStatic.updateDiscoveryRequest();
     }
 
     static void selectDefaultRouteStatic() {
@@ -1291,10 +1291,8 @@
     }
 
     static void updateWifiDisplayStatus(WifiDisplayStatus status) {
-        boolean wantScan = false;
         WifiDisplay[] displays;
         WifiDisplay activeDisplay;
-
         if (status.getFeatureState() == WifiDisplayStatus.FEATURE_STATE_ON) {
             displays = status.getDisplays();
             activeDisplay = status.getActiveDisplay();
@@ -1314,6 +1312,8 @@
             displays = WifiDisplay.EMPTY_ARRAY;
             activeDisplay = null;
         }
+        String activeDisplayAddress = activeDisplay != null ?
+                activeDisplay.getDeviceAddress() : null;
 
         // Add or update routes.
         for (int i = 0; i < displays.length; i++) {
@@ -1323,9 +1323,11 @@
                 if (route == null) {
                     route = makeWifiDisplayRoute(d, status);
                     addRouteStatic(route);
-                    wantScan = true;
                 } else {
-                    updateWifiDisplayRoute(route, d, status);
+                    String address = d.getDeviceAddress();
+                    boolean disconnected = !address.equals(activeDisplayAddress)
+                            && address.equals(sStatic.mPreviousActiveWifiDisplayAddress);
+                    updateWifiDisplayRoute(route, d, status, disconnected);
                 }
                 if (d.equals(activeDisplay)) {
                     selectRouteStatic(route.getSupportedTypes(), route, false);
@@ -1344,11 +1346,9 @@
             }
         }
 
-        // Don't scan if we're already connected to a wifi display,
-        // the scanning process can cause a hiccup with some configurations.
-        if (wantScan && activeDisplay != null && sStatic.mCanConfigureWifiDisplays) {
-            sStatic.mDisplayService.scanWifiDisplays();
-        }
+        // Remember the current active wifi display address so that we can infer disconnections.
+        // TODO: This hack will go away once all of this is moved into the media router service.
+        sStatic.mPreviousActiveWifiDisplayAddress = activeDisplayAddress;
     }
 
     private static boolean shouldShowWifiDisplay(WifiDisplay d, WifiDisplay activeDisplay) {
@@ -1406,7 +1406,8 @@
     }
 
     private static void updateWifiDisplayRoute(
-            RouteInfo route, WifiDisplay display, WifiDisplayStatus wfdStatus) {
+            RouteInfo route, WifiDisplay display, WifiDisplayStatus wfdStatus,
+            boolean disconnected) {
         boolean changed = false;
         final String newName = display.getFriendlyDisplayName();
         if (!route.getName().equals(newName)) {
@@ -1424,7 +1425,7 @@
             dispatchRouteChanged(route);
         }
 
-        if (!enabled && route.isSelected()) {
+        if ((!enabled || disconnected) && route.isSelected()) {
             // Oops, no longer available. Reselect the default.
             selectDefaultRouteStatic();
         }
diff --git a/packages/DocumentsUI/src/com/android/documentsui/FilteringCursorWrapper.java b/packages/DocumentsUI/src/com/android/documentsui/FilteringCursorWrapper.java
index 55d73f23..1cbc221 100644
--- a/packages/DocumentsUI/src/com/android/documentsui/FilteringCursorWrapper.java
+++ b/packages/DocumentsUI/src/com/android/documentsui/FilteringCursorWrapper.java
@@ -51,7 +51,7 @@
         mPosition = new int[count];
 
         cursor.moveToPosition(-1);
-        while (cursor.moveToNext()) {
+        while (cursor.moveToNext() && mCount < count) {
             final String mimeType = getCursorString(cursor, Document.COLUMN_MIME_TYPE);
             final long lastModified = getCursorLong(cursor, Document.COLUMN_LAST_MODIFIED);
             if (rejectMimes != null && MimePredicate.mimeMatches(rejectMimes, mimeType)) {
diff --git a/packages/DocumentsUI/src/com/android/documentsui/RecentLoader.java b/packages/DocumentsUI/src/com/android/documentsui/RecentLoader.java
index 3a8a3fb..34ce42d 100644
--- a/packages/DocumentsUI/src/com/android/documentsui/RecentLoader.java
+++ b/packages/DocumentsUI/src/com/android/documentsui/RecentLoader.java
@@ -55,6 +55,10 @@
 public class RecentLoader extends AsyncTaskLoader<DirectoryResult> {
     private static final boolean LOGD = true;
 
+    // TODO: clean up cursor ownership so background thread doesn't traverse
+    // previously returned cursors for filtering/sorting; this currently races
+    // with the UI thread.
+
     private static final int MAX_OUTSTANDING_RECENTS = 4;
     private static final int MAX_OUTSTANDING_RECENTS_SVELTE = 2;
 
diff --git a/packages/PrintSpooler/src/com/android/printspooler/PrintJobConfigActivity.java b/packages/PrintSpooler/src/com/android/printspooler/PrintJobConfigActivity.java
index 88403a3..c1c7a4e 100644
--- a/packages/PrintSpooler/src/com/android/printspooler/PrintJobConfigActivity.java
+++ b/packages/PrintSpooler/src/com/android/printspooler/PrintJobConfigActivity.java
@@ -1529,9 +1529,13 @@
                                 builder.append(',');
                             }
                             PageRange pageRange = pageRanges[i];
-                            builder.append(pageRange.getStart());
-                            builder.append('-');
-                            builder.append(pageRange.getEnd());
+                            final int shownStartPage = pageRange.getStart() + 1;
+                            final int shownEndPage = pageRange.getEnd() + 1;
+                            builder.append(shownStartPage);
+                            if (shownStartPage != shownEndPage) {
+                                builder.append('-');
+                                builder.append(shownEndPage);
+                            }
                         }
                         mPageRangeEditText.setText(builder.toString());
                     }
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/QuickSettingsModel.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/QuickSettingsModel.java
index e1a20ec..42201c5 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/QuickSettingsModel.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/QuickSettingsModel.java
@@ -692,14 +692,8 @@
         } else {
             connectedRoute = null;
             connecting = false;
-            final int count = mMediaRouter.getRouteCount();
-            for (int i = 0; i < count; i++) {
-                MediaRouter.RouteInfo route = mMediaRouter.getRouteAt(i);
-                if (route.matchesTypes(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY)) {
-                    enabled = true;
-                    break;
-                }
-            }
+            enabled = mMediaRouter.isRouteAvailable(MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY,
+                    MediaRouter.AVAILABILITY_FLAG_IGNORE_DEFAULT_ROUTE);
         }
 
         mRemoteDisplayState.enabled = enabled;
diff --git a/services/java/com/android/server/BackupManagerService.java b/services/java/com/android/server/BackupManagerService.java
index baef607..00bfee7 100644
--- a/services/java/com/android/server/BackupManagerService.java
+++ b/services/java/com/android/server/BackupManagerService.java
@@ -161,6 +161,9 @@
     // the first backup pass.
     private static final long FIRST_BACKUP_INTERVAL = 12 * AlarmManager.INTERVAL_HOUR;
 
+    // Retry interval for clear/init when the transport is unavailable
+    private static final long TRANSPORT_RETRY_INTERVAL = 1 * AlarmManager.INTERVAL_HOUR;
+
     private static final String RUN_BACKUP_ACTION = "android.app.backup.intent.RUN";
     private static final String RUN_INITIALIZE_ACTION = "android.app.backup.intent.INIT";
     private static final String RUN_CLEAR_ACTION = "android.app.backup.intent.CLEAR";
@@ -174,6 +177,8 @@
     private static final int MSG_RESTORE_TIMEOUT = 8;
     private static final int MSG_FULL_CONFIRMATION_TIMEOUT = 9;
     private static final int MSG_RUN_FULL_RESTORE = 10;
+    private static final int MSG_RETRY_INIT = 11;
+    private static final int MSG_RETRY_CLEAR = 12;
 
     // backup task state machine tick
     static final int MSG_BACKUP_RESTORE_STEP = 20;
@@ -306,6 +311,7 @@
 
     class RestoreParams {
         public IBackupTransport transport;
+        public String dirName;
         public IRestoreObserver observer;
         public long token;
         public PackageInfo pkgInfo;
@@ -313,9 +319,10 @@
         public boolean needFullBackup;
         public String[] filterSet;
 
-        RestoreParams(IBackupTransport _transport, IRestoreObserver _obs,
+        RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
                 long _token, PackageInfo _pkg, int _pmToken, boolean _needFullBackup) {
             transport = _transport;
+            dirName = _dirName;
             observer = _obs;
             token = _token;
             pkgInfo = _pkg;
@@ -324,9 +331,10 @@
             filterSet = null;
         }
 
-        RestoreParams(IBackupTransport _transport, IRestoreObserver _obs, long _token,
-                boolean _needFullBackup) {
+        RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
+                long _token, boolean _needFullBackup) {
             transport = _transport;
+            dirName = _dirName;
             observer = _obs;
             token = _token;
             pkgInfo = null;
@@ -335,9 +343,10 @@
             filterSet = null;
         }
 
-        RestoreParams(IBackupTransport _transport, IRestoreObserver _obs, long _token,
-                String[] _filterSet, boolean _needFullBackup) {
+        RestoreParams(IBackupTransport _transport, String _dirName, IRestoreObserver _obs,
+                long _token, String[] _filterSet, boolean _needFullBackup) {
             transport = _transport;
+            dirName = _dirName;
             observer = _obs;
             token = _token;
             pkgInfo = null;
@@ -357,6 +366,16 @@
         }
     }
 
+    class ClearRetryParams {
+        public String transportName;
+        public String packageName;
+
+        ClearRetryParams(String transport, String pkg) {
+            transportName = transport;
+            packageName = pkg;
+        }
+    }
+
     class FullParams {
         public ParcelFileDescriptor fd;
         public final AtomicBoolean latch;
@@ -516,13 +535,28 @@
                 // When it completes successfully, that old journal file will be
                 // deleted.  If we crash prior to that, the old journal is parsed
                 // at next boot and the journaled requests fulfilled.
+                boolean staged = true;
                 if (queue.size() > 0) {
                     // Spin up a backup state sequence and set it running
-                    PerformBackupTask pbt = new PerformBackupTask(transport, queue, oldJournal);
-                    Message pbtMessage = obtainMessage(MSG_BACKUP_RESTORE_STEP, pbt);
-                    sendMessage(pbtMessage);
+                    try {
+                        String dirName = transport.transportDirName();
+                        PerformBackupTask pbt = new PerformBackupTask(transport, dirName,
+                                queue, oldJournal);
+                        Message pbtMessage = obtainMessage(MSG_BACKUP_RESTORE_STEP, pbt);
+                        sendMessage(pbtMessage);
+                    } catch (RemoteException e) {
+                        // unable to ask the transport its dir name -- transient failure, since
+                        // the above check succeeded.  Try again next time.
+                        Slog.e(TAG, "Transport became unavailable attempting backup");
+                        staged = false;
+                    }
                 } else {
                     Slog.v(TAG, "Backup requested but nothing pending");
+                    staged = false;
+                }
+
+                if (!staged) {
+                    // if we didn't actually hand off the wakelock, rewind until next time
                     synchronized (mQueueLock) {
                         mBackupRunning = false;
                     }
@@ -572,7 +606,7 @@
                 RestoreParams params = (RestoreParams)msg.obj;
                 Slog.d(TAG, "MSG_RUN_RESTORE observer=" + params.observer);
                 PerformRestoreTask task = new PerformRestoreTask(
-                        params.transport, params.observer,
+                        params.transport, params.dirName, params.observer,
                         params.token, params.pkgInfo, params.pmToken,
                         params.needFullBackup, params.filterSet);
                 Message restoreMsg = obtainMessage(MSG_BACKUP_RESTORE_STEP, task);
@@ -599,6 +633,14 @@
                 break;
             }
 
+            case MSG_RETRY_CLEAR:
+            {
+                // reenqueues if the transport remains unavailable
+                ClearRetryParams params = (ClearRetryParams)msg.obj;
+                clearBackupData(params.transportName, params.packageName);
+                break;
+            }
+
             case MSG_RUN_INITIALIZE:
             {
                 HashSet<String> queue;
@@ -613,6 +655,16 @@
                 break;
             }
 
+            case MSG_RETRY_INIT:
+            {
+                synchronized (mQueueLock) {
+                    recordInitPendingLocked(msg.arg1 != 0, (String)msg.obj);
+                    mAlarmManager.set(AlarmManager.RTC_WAKEUP, System.currentTimeMillis(),
+                            mRunInitIntent);
+                }
+                break;
+            }
+
             case MSG_RUN_GET_RESTORE_SETS:
             {
                 // Like other async operations, this is entered with the wakelock held
@@ -1250,29 +1302,47 @@
     void recordInitPendingLocked(boolean isPending, String transportName) {
         if (DEBUG) Slog.i(TAG, "recordInitPendingLocked: " + isPending
                 + " on transport " + transportName);
+        mBackupHandler.removeMessages(MSG_RETRY_INIT);
+
         try {
             IBackupTransport transport = getTransport(transportName);
-            String transportDirName = transport.transportDirName();
-            File stateDir = new File(mBaseStateDir, transportDirName);
-            File initPendingFile = new File(stateDir, INIT_SENTINEL_FILE_NAME);
+            if (transport != null) {
+                String transportDirName = transport.transportDirName();
+                File stateDir = new File(mBaseStateDir, transportDirName);
+                File initPendingFile = new File(stateDir, INIT_SENTINEL_FILE_NAME);
 
-            if (isPending) {
-                // We need an init before we can proceed with sending backup data.
-                // Record that with an entry in our set of pending inits, as well as
-                // journaling it via creation of a sentinel file.
-                mPendingInits.add(transportName);
-                try {
-                    (new FileOutputStream(initPendingFile)).close();
-                } catch (IOException ioe) {
-                    // Something is badly wrong with our permissions; just try to move on
+                if (isPending) {
+                    // We need an init before we can proceed with sending backup data.
+                    // Record that with an entry in our set of pending inits, as well as
+                    // journaling it via creation of a sentinel file.
+                    mPendingInits.add(transportName);
+                    try {
+                        (new FileOutputStream(initPendingFile)).close();
+                    } catch (IOException ioe) {
+                        // Something is badly wrong with our permissions; just try to move on
+                    }
+                } else {
+                    // No more initialization needed; wipe the journal and reset our state.
+                    initPendingFile.delete();
+                    mPendingInits.remove(transportName);
                 }
-            } else {
-                // No more initialization needed; wipe the journal and reset our state.
-                initPendingFile.delete();
-                mPendingInits.remove(transportName);
+                return; // done; don't fall through to the error case
             }
         } catch (RemoteException e) {
-            // can't happen; the transport is local
+            // transport threw when asked its name; fall through to the lookup-failed case
+        }
+
+        // The named transport doesn't exist or threw.  This operation is
+        // important, so we record the need for a an init and post a message
+        // to retry the init later.
+        if (isPending) {
+            mPendingInits.add(transportName);
+            mBackupHandler.sendMessageDelayed(
+                    mBackupHandler.obtainMessage(MSG_RETRY_INIT,
+                            (isPending ? 1 : 0),
+                            0,
+                            transportName),
+                    TRANSPORT_RETRY_INTERVAL);
         }
     }
 
@@ -1348,7 +1418,10 @@
                 }
             }
         } catch (RemoteException e) {
-            // can't happen, the transport is local
+            // the transport threw when asked its file naming prefs; declare it invalid
+            Slog.e(TAG, "Unable to register transport as " + name);
+            mTransportNames.remove(component);
+            mTransports.remove(name);
         }
     }
 
@@ -1668,7 +1741,7 @@
                     agent = mConnectedAgent;
                 }
             } catch (RemoteException e) {
-                // can't happen
+                // can't happen - ActivityManager is local
             }
         }
         return agent;
@@ -1844,17 +1917,13 @@
         int mStatus;
         boolean mFinished;
 
-        public PerformBackupTask(IBackupTransport transport, ArrayList<BackupRequest> queue,
-                File journal) {
+        public PerformBackupTask(IBackupTransport transport, String dirName,
+                ArrayList<BackupRequest> queue, File journal) {
             mTransport = transport;
             mOriginalQueue = queue;
             mJournal = journal;
 
-            try {
-                mStateDir = new File(mBaseStateDir, transport.transportDirName());
-            } catch (RemoteException e) {
-                // can't happen; the transport is local
-            }
+            mStateDir = new File(mBaseStateDir, dirName);
 
             mCurrentState = BackupState.INITIAL;
             mFinished = false;
@@ -2100,8 +2169,12 @@
                 addBackupTrace("success; recording token");
                 try {
                     mCurrentToken = mTransport.getCurrentRestoreSet();
-                } catch (RemoteException e) {} // can't happen
-                writeRestoreTokens();
+                    writeRestoreTokens();
+                } catch (RemoteException e) {
+                    // nothing for it at this point, unfortunately, but this will be
+                    // recorded the next time we fully succeed.
+                    addBackupTrace("transport threw returning token");
+                }
             }
 
             // Set up the next backup pass - at this point we can set mBackupRunning
@@ -2322,7 +2395,7 @@
                 addBackupTrace("unbinding " + mCurrentPackage.packageName);
                 try {  // unbind even on timeout, just in case
                     mActivityManager.unbindBackupAgent(mCurrentPackage.applicationInfo);
-                } catch (RemoteException e) {}
+                } catch (RemoteException e) { /* can't happen; activity manager is local */ }
             }
         }
 
@@ -4337,7 +4410,7 @@
             }
         }
 
-        PerformRestoreTask(IBackupTransport transport, IRestoreObserver observer,
+        PerformRestoreTask(IBackupTransport transport, String dirName, IRestoreObserver observer,
                 long restoreSetToken, PackageInfo targetPackage, int pmToken,
                 boolean needFullBackup, String[] filterSet) {
             mCurrentState = RestoreState.INITIAL;
@@ -4360,11 +4433,7 @@
                 mFilterSet = null;
             }
 
-            try {
-                mStateDir = new File(mBaseStateDir, transport.transportDirName());
-            } catch (RemoteException e) {
-                // can't happen; the transport is local
-            }
+            mStateDir = new File(mBaseStateDir, dirName);
         }
 
         // Execute one tick of whatever state machine the task implements
@@ -5090,8 +5159,8 @@
     }
 
     // Clear the given package's backup data from the current transport
-    public void clearBackupData(String packageName) {
-        if (DEBUG) Slog.v(TAG, "clearBackupData() of " + packageName);
+    public void clearBackupData(String transportName, String packageName) {
+        if (DEBUG) Slog.v(TAG, "clearBackupData() of " + packageName + " on " + transportName);
         PackageInfo info;
         try {
             info = mPackageManager.getPackageInfo(packageName, PackageManager.GET_SIGNATURES);
@@ -5122,13 +5191,22 @@
 
         // Is the given app an available participant?
         if (apps.contains(packageName)) {
-            if (DEBUG) Slog.v(TAG, "Found the app - running clear process");
             // found it; fire off the clear request
+            if (DEBUG) Slog.v(TAG, "Found the app - running clear process");
+            mBackupHandler.removeMessages(MSG_RETRY_CLEAR);
             synchronized (mQueueLock) {
+                final IBackupTransport transport = getTransport(transportName);
+                if (transport == null) {
+                    // transport is currently unavailable -- make sure to retry
+                    Message msg = mBackupHandler.obtainMessage(MSG_RETRY_CLEAR,
+                            new ClearRetryParams(transportName, packageName));
+                    mBackupHandler.sendMessageDelayed(msg, TRANSPORT_RETRY_INTERVAL);
+                    return;
+                }
                 long oldId = Binder.clearCallingIdentity();
                 mWakelock.acquire();
                 Message msg = mBackupHandler.obtainMessage(MSG_RUN_CLEAR,
-                        new ClearParams(getTransport(mCurrentTransport), info));
+                        new ClearParams(transport, info));
                 mBackupHandler.sendMessage(msg);
                 Binder.restoreCallingIdentity(oldId);
             }
@@ -5626,21 +5704,36 @@
                 + " restoreSet=" + Long.toHexString(restoreSet));
 
         if (mAutoRestore && mProvisioned && restoreSet != 0) {
-            // okay, we're going to attempt a restore of this package from this restore set.
-            // The eventual message back into the Package Manager to run the post-install
-            // steps for 'token' will be issued from the restore handling code.
+            // Do we have a transport to fetch data for us?
+            IBackupTransport transport = getTransport(mCurrentTransport);
+            if (transport == null) {
+                if (DEBUG) Slog.w(TAG, "No transport for install-time restore");
+                return;
+            }
 
-            // We can use a synthetic PackageInfo here because:
-            //   1. We know it's valid, since the Package Manager supplied the name
-            //   2. Only the packageName field will be used by the restore code
-            PackageInfo pkg = new PackageInfo();
-            pkg.packageName = packageName;
+            try {
+                // okay, we're going to attempt a restore of this package from this restore set.
+                // The eventual message back into the Package Manager to run the post-install
+                // steps for 'token' will be issued from the restore handling code.
 
-            mWakelock.acquire();
-            Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
-            msg.obj = new RestoreParams(getTransport(mCurrentTransport), null,
-                    restoreSet, pkg, token, true);
-            mBackupHandler.sendMessage(msg);
+                // This can throw and so *must* happen before the wakelock is acquired
+                String dirName = transport.transportDirName();
+
+                // We can use a synthetic PackageInfo here because:
+                //   1. We know it's valid, since the Package Manager supplied the name
+                //   2. Only the packageName field will be used by the restore code
+                PackageInfo pkg = new PackageInfo();
+                pkg.packageName = packageName;
+
+                mWakelock.acquire();
+                Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
+                msg.obj = new RestoreParams(transport, dirName, null,
+                        restoreSet, pkg, token, true);
+                mBackupHandler.sendMessage(msg);
+            } catch (RemoteException e) {
+                // Binding to the transport broke; back off and proceed with the installation.
+                Slog.e(TAG, "Unable to contact transport for install-time restore");
+            }
         } else {
             // Auto-restore disabled or no way to attempt a restore; just tell the Package
             // Manager to proceed with the post-install handling for this package.
@@ -5797,13 +5890,23 @@
                 return -1;
             }
 
+            String dirName;
+            try {
+                dirName = mRestoreTransport.transportDirName();
+            } catch (RemoteException e) {
+                // Transport went AWOL; fail.
+                Slog.e(TAG, "Unable to contact transport for restore");
+                return -1;
+            }
+
             synchronized (mQueueLock) {
                 for (int i = 0; i < mRestoreSets.length; i++) {
                     if (token == mRestoreSets[i].token) {
                         long oldId = Binder.clearCallingIdentity();
                         mWakelock.acquire();
                         Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
-                        msg.obj = new RestoreParams(mRestoreTransport, observer, token, true);
+                        msg.obj = new RestoreParams(mRestoreTransport, dirName,
+                                observer, token, true);
                         mBackupHandler.sendMessage(msg);
                         Binder.restoreCallingIdentity(oldId);
                         return 0;
@@ -5857,13 +5960,22 @@
                 return -1;
             }
 
+            String dirName;
+            try {
+                dirName = mRestoreTransport.transportDirName();
+            } catch (RemoteException e) {
+                // Transport went AWOL; fail.
+                Slog.e(TAG, "Unable to contact transport for restore");
+                return -1;
+            }
+
             synchronized (mQueueLock) {
                 for (int i = 0; i < mRestoreSets.length; i++) {
                     if (token == mRestoreSets[i].token) {
                         long oldId = Binder.clearCallingIdentity();
                         mWakelock.acquire();
                         Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
-                        msg.obj = new RestoreParams(mRestoreTransport, observer, token,
+                        msg.obj = new RestoreParams(mRestoreTransport, dirName, observer, token,
                                 packages, true);
                         mBackupHandler.sendMessage(msg);
                         Binder.restoreCallingIdentity(oldId);
@@ -5929,11 +6041,21 @@
                 return -1;
             }
 
+            String dirName;
+            try {
+                dirName = mRestoreTransport.transportDirName();
+            } catch (RemoteException e) {
+                // Transport went AWOL; fail.
+                Slog.e(TAG, "Unable to contact transport for restore");
+                return -1;
+            }
+
             // Ready to go:  enqueue the restore request and claim success
             long oldId = Binder.clearCallingIdentity();
             mWakelock.acquire();
             Message msg = mBackupHandler.obtainMessage(MSG_RUN_RESTORE);
-            msg.obj = new RestoreParams(mRestoreTransport, observer, token, app, 0, false);
+            msg.obj = new RestoreParams(mRestoreTransport, dirName,
+                    observer, token, app, 0, false);
             mBackupHandler.sendMessage(msg);
             Binder.restoreCallingIdentity(oldId);
             return 0;
diff --git a/services/java/com/android/server/am/ActiveServices.java b/services/java/com/android/server/am/ActiveServices.java
index 933247e..89bddc6 100644
--- a/services/java/com/android/server/am/ActiveServices.java
+++ b/services/java/com/android/server/am/ActiveServices.java
@@ -1847,7 +1847,7 @@
                 }
             }
             if (finishing) {
-                if (r.app != null) {
+                if (r.app != null && !r.app.persistent) {
                     r.app.services.remove(r);
                 }
                 r.app = null;
@@ -1930,7 +1930,9 @@
                 Slog.i(TAG, "  Force stopping service " + service);
                 if (service.app != null) {
                     service.app.removed = true;
-                    service.app.services.remove(service);
+                    if (!service.app.persistent) {
+                        service.app.services.remove(service);
+                    }
                 }
                 service.app = null;
                 service.isolatedProc = null;
@@ -2032,7 +2034,7 @@
             synchronized (sr.stats.getBatteryStats()) {
                 sr.stats.stopLaunchedLocked();
             }
-            if (sr.app != null) {
+            if (sr.app != null && !sr.app.persistent) {
                 sr.app.services.remove(sr);
             }
             sr.app = null;
diff --git a/services/java/com/android/server/display/DisplayManagerService.java b/services/java/com/android/server/display/DisplayManagerService.java
index 02f26b3..bcb677f 100644
--- a/services/java/com/android/server/display/DisplayManagerService.java
+++ b/services/java/com/android/server/display/DisplayManagerService.java
@@ -35,6 +35,7 @@
 import android.os.SystemClock;
 import android.os.SystemProperties;
 import android.text.TextUtils;
+import android.util.Log;
 import android.util.Slog;
 import android.util.SparseArray;
 import android.view.Display;
@@ -173,6 +174,9 @@
     // The Wifi display adapter, or null if not registered.
     private WifiDisplayAdapter mWifiDisplayAdapter;
 
+    // The number of active wifi display scan requests.
+    private int mWifiDisplayScanRequestCount;
+
     // The virtual display adapter, or null if not registered.
     private VirtualDisplayAdapter mVirtualDisplayAdapter;
 
@@ -458,29 +462,81 @@
         }
     }
 
-    private void onCallbackDied(int pid) {
+    private void onCallbackDied(CallbackRecord record) {
         synchronized (mSyncRoot) {
-            mCallbacks.remove(pid);
+            mCallbacks.remove(record.mPid);
+            stopWifiDisplayScanLocked(record);
         }
     }
 
     @Override // Binder call
-    public void scanWifiDisplays() {
+    public void startWifiDisplayScan() {
         mContext.enforceCallingOrSelfPermission(Manifest.permission.CONFIGURE_WIFI_DISPLAY,
-                "Permission required to scan wifi displays");
+                "Permission required to start wifi display scans");
 
+        final int callingPid = Binder.getCallingPid();
         final long token = Binder.clearCallingIdentity();
         try {
             synchronized (mSyncRoot) {
-                if (mWifiDisplayAdapter != null) {
-                    mWifiDisplayAdapter.requestScanLocked();
+                CallbackRecord record = mCallbacks.get(callingPid);
+                if (record == null) {
+                    throw new IllegalStateException("The calling process has not "
+                            + "registered an IDisplayManagerCallback.");
                 }
+                startWifiDisplayScanLocked(record);
             }
         } finally {
             Binder.restoreCallingIdentity(token);
         }
     }
 
+    private void startWifiDisplayScanLocked(CallbackRecord record) {
+        if (!record.mWifiDisplayScanRequested) {
+            record.mWifiDisplayScanRequested = true;
+            if (mWifiDisplayScanRequestCount++ == 0) {
+                if (mWifiDisplayAdapter != null) {
+                    mWifiDisplayAdapter.requestStartScanLocked();
+                }
+            }
+        }
+    }
+
+    @Override // Binder call
+    public void stopWifiDisplayScan() {
+        mContext.enforceCallingOrSelfPermission(Manifest.permission.CONFIGURE_WIFI_DISPLAY,
+                "Permission required to stop wifi display scans");
+
+        final int callingPid = Binder.getCallingPid();
+        final long token = Binder.clearCallingIdentity();
+        try {
+            synchronized (mSyncRoot) {
+                CallbackRecord record = mCallbacks.get(callingPid);
+                if (record == null) {
+                    throw new IllegalStateException("The calling process has not "
+                            + "registered an IDisplayManagerCallback.");
+                }
+                stopWifiDisplayScanLocked(record);
+            }
+        } finally {
+            Binder.restoreCallingIdentity(token);
+        }
+    }
+
+    private void stopWifiDisplayScanLocked(CallbackRecord record) {
+        if (record.mWifiDisplayScanRequested) {
+            record.mWifiDisplayScanRequested = false;
+            if (--mWifiDisplayScanRequestCount == 0) {
+                if (mWifiDisplayAdapter != null) {
+                    mWifiDisplayAdapter.requestStopScanLocked();
+                }
+            } else if (mWifiDisplayScanRequestCount < 0) {
+                Log.wtf(TAG, "mWifiDisplayScanRequestCount became negative: "
+                        + mWifiDisplayScanRequestCount);
+                mWifiDisplayScanRequestCount = 0;
+            }
+        }
+    }
+
     @Override // Binder call
     public void connectWifiDisplay(String address) {
         if (address == null) {
@@ -1107,6 +1163,7 @@
             pw.println("  mDefaultViewport=" + mDefaultViewport);
             pw.println("  mExternalTouchViewport=" + mExternalTouchViewport);
             pw.println("  mSingleDisplayDemoMode=" + mSingleDisplayDemoMode);
+            pw.println("  mWifiDisplayScanRequestCount=" + mWifiDisplayScanRequestCount);
 
             IndentingPrintWriter ipw = new IndentingPrintWriter(pw, "    ");
             ipw.increaseIndent();
@@ -1134,6 +1191,15 @@
                 pw.println("  Display " + displayId + ":");
                 display.dumpLocked(ipw);
             }
+
+            final int callbackCount = mCallbacks.size();
+            pw.println();
+            pw.println("Callbacks: size=" + callbackCount);
+            for (int i = 0; i < callbackCount; i++) {
+                CallbackRecord callback = mCallbacks.valueAt(i);
+                pw.println("  " + i + ": mPid=" + callback.mPid
+                        + ", mWifiDisplayScanRequested=" + callback.mWifiDisplayScanRequested);
+            }
         }
     }
 
@@ -1234,9 +1300,11 @@
     }
 
     private final class CallbackRecord implements DeathRecipient {
-        private final int mPid;
+        public final int mPid;
         private final IDisplayManagerCallback mCallback;
 
+        public boolean mWifiDisplayScanRequested;
+
         public CallbackRecord(int pid, IDisplayManagerCallback callback) {
             mPid = pid;
             mCallback = callback;
@@ -1247,7 +1315,7 @@
             if (DEBUG) {
                 Slog.d(TAG, "Display listener for pid " + mPid + " died.");
             }
-            onCallbackDied(mPid);
+            onCallbackDied(this);
         }
 
         public void notifyDisplayEventAsync(int displayId, int event) {
diff --git a/services/java/com/android/server/display/WifiDisplayAdapter.java b/services/java/com/android/server/display/WifiDisplayAdapter.java
index fdef039..cd57941 100644
--- a/services/java/com/android/server/display/WifiDisplayAdapter.java
+++ b/services/java/com/android/server/display/WifiDisplayAdapter.java
@@ -127,7 +127,7 @@
         pw.println("mPendingStatusChangeBroadcast=" + mPendingStatusChangeBroadcast);
         pw.println("mPendingNotificationUpdate=" + mPendingNotificationUpdate);
         pw.println("mSupportsProtectedBuffers=" + mSupportsProtectedBuffers);
-
+ 
         // Try to dump the controller state.
         if (mDisplayController == null) {
             pw.println("mDisplayController=null");
@@ -157,16 +157,31 @@
         });
     }
 
-    public void requestScanLocked() {
+    public void requestStartScanLocked() {
         if (DEBUG) {
-            Slog.d(TAG, "requestScanLocked");
+            Slog.d(TAG, "requestStartScanLocked");
         }
 
         getHandler().post(new Runnable() {
             @Override
             public void run() {
                 if (mDisplayController != null) {
-                    mDisplayController.requestScan();
+                    mDisplayController.requestStartScan();
+                }
+            }
+        });
+    }
+
+    public void requestStopScanLocked() {
+        if (DEBUG) {
+            Slog.d(TAG, "requestStopScanLocked");
+        }
+
+        getHandler().post(new Runnable() {
+            @Override
+            public void run() {
+                if (mDisplayController != null) {
+                    mDisplayController.requestStopScan();
                 }
             }
         });
@@ -187,15 +202,6 @@
         });
     }
 
-    private boolean isRememberedDisplayLocked(String address) {
-        for (WifiDisplay display : mRememberedDisplays) {
-            if (display.getDeviceAddress().equals(address)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     public void requestPauseLocked() {
         if (DEBUG) {
             Slog.d(TAG, "requestPauseLocked");
@@ -552,20 +558,20 @@
         }
 
         @Override
-        public void onScanFinished(WifiDisplay[] availableDisplays) {
+        public void onScanResults(WifiDisplay[] availableDisplays) {
             synchronized (getSyncRoot()) {
                 availableDisplays = mPersistentDataStore.applyWifiDisplayAliases(
                         availableDisplays);
 
-                // check if any of the available displays changed canConnect status
                 boolean changed = !Arrays.equals(mAvailableDisplays, availableDisplays);
+
+                // Check whether any of the available displays changed canConnect status.
                 for (int i = 0; !changed && i<availableDisplays.length; i++) {
                     changed = availableDisplays[i].canConnect()
                             != mAvailableDisplays[i].canConnect();
                 }
 
-                if (mScanState != WifiDisplayStatus.SCAN_STATE_NOT_SCANNING || changed) {
-                    mScanState = WifiDisplayStatus.SCAN_STATE_NOT_SCANNING;
+                if (changed) {
                     mAvailableDisplays = availableDisplays;
                     fixRememberedDisplayNamesFromAvailableDisplaysLocked();
                     updateDisplaysLocked();
@@ -575,6 +581,16 @@
         }
 
         @Override
+        public void onScanFinished() {
+            synchronized (getSyncRoot()) {
+                if (mScanState != WifiDisplayStatus.SCAN_STATE_NOT_SCANNING) {
+                    mScanState = WifiDisplayStatus.SCAN_STATE_NOT_SCANNING;
+                    scheduleStatusChangedBroadcastLocked();
+                }
+            }
+        }
+
+        @Override
         public void onDisplayConnecting(WifiDisplay display) {
             synchronized (getSyncRoot()) {
                 display = mPersistentDataStore.applyWifiDisplayAlias(display);
diff --git a/services/java/com/android/server/display/WifiDisplayController.java b/services/java/com/android/server/display/WifiDisplayController.java
index b2939fe..dbb59b2 100644
--- a/services/java/com/android/server/display/WifiDisplayController.java
+++ b/services/java/com/android/server/display/WifiDisplayController.java
@@ -27,7 +27,6 @@
 import android.hardware.display.WifiDisplay;
 import android.hardware.display.WifiDisplaySessionInfo;
 import android.hardware.display.WifiDisplayStatus;
-import android.media.AudioManager;
 import android.media.RemoteDisplay;
 import android.net.NetworkInfo;
 import android.net.Uri;
@@ -75,12 +74,19 @@
 
     private static final int DEFAULT_CONTROL_PORT = 7236;
     private static final int MAX_THROUGHPUT = 50;
-    private static final int CONNECTION_TIMEOUT_SECONDS = 60;
+    private static final int CONNECTION_TIMEOUT_SECONDS = 30;
     private static final int RTSP_TIMEOUT_SECONDS = 30;
     private static final int RTSP_TIMEOUT_SECONDS_CERT_MODE = 120;
 
-    private static final int DISCOVER_PEERS_MAX_RETRIES = 10;
-    private static final int DISCOVER_PEERS_RETRY_DELAY_MILLIS = 500;
+    // We repeatedly issue calls to discover peers every so often for a few reasons.
+    // 1. The initial request may fail and need to retried.
+    // 2. Discovery will self-abort after any group is initiated, which may not necessarily
+    //    be what we want to have happen.
+    // 3. Discovery will self-timeout after 2 minutes, whereas we want discovery to
+    //    be occur for as long as a client is requesting it be.
+    // 4. We don't seem to get updated results for displays we've already found until
+    //    we ask to discover again, particularly for the isSessionAvailable() property.
+    private static final int DISCOVER_PEERS_INTERVAL_MILLIS = 10000;
 
     private static final int CONNECT_MAX_RETRIES = 3;
     private static final int CONNECT_RETRY_DELAY_MILLIS = 500;
@@ -103,12 +109,12 @@
     // True if Wifi display is enabled by the user.
     private boolean mWifiDisplayOnSetting;
 
+    // True if a scan was requested independent of whether one is actually in progress.
+    private boolean mScanRequested;
+
     // True if there is a call to discoverPeers in progress.
     private boolean mDiscoverPeersInProgress;
 
-    // Number of discover peers retries remaining.
-    private int mDiscoverPeersRetriesLeft;
-
     // The device to which we want to connect, or null if we want to be disconnected.
     private WifiP2pDevice mDesiredDevice;
 
@@ -209,8 +215,8 @@
         pw.println("mWfdEnabled=" + mWfdEnabled);
         pw.println("mWfdEnabling=" + mWfdEnabling);
         pw.println("mNetworkInfo=" + mNetworkInfo);
+        pw.println("mScanRequested=" + mScanRequested);
         pw.println("mDiscoverPeersInProgress=" + mDiscoverPeersInProgress);
-        pw.println("mDiscoverPeersRetriesLeft=" + mDiscoverPeersRetriesLeft);
         pw.println("mDesiredDevice=" + describeWifiP2pDevice(mDesiredDevice));
         pw.println("mConnectingDisplay=" + describeWifiP2pDevice(mConnectingDevice));
         pw.println("mDisconnectingDisplay=" + describeWifiP2pDevice(mDisconnectingDevice));
@@ -232,8 +238,18 @@
         }
     }
 
-    public void requestScan() {
-        discoverPeers();
+    public void requestStartScan() {
+        if (!mScanRequested) {
+            mScanRequested = true;
+            updateScanState();
+        }
+    }
+
+    public void requestStopScan() {
+        if (mScanRequested) {
+            mScanRequested = false;
+            updateScanState();
+        }
     }
 
     public void requestConnect(String address) {
@@ -282,6 +298,7 @@
                             mWfdEnabling = false;
                             mWfdEnabled = true;
                             reportFeatureState();
+                            updateScanState();
                         }
                     }
 
@@ -318,6 +335,7 @@
             mWfdEnabling = false;
             mWfdEnabled = false;
             reportFeatureState();
+            updateScanState();
             disconnect();
         }
     }
@@ -340,12 +358,29 @@
                 WifiDisplayStatus.FEATURE_STATE_OFF;
     }
 
-    private void discoverPeers() {
-        if (!mDiscoverPeersInProgress) {
-            mDiscoverPeersInProgress = true;
-            mDiscoverPeersRetriesLeft = DISCOVER_PEERS_MAX_RETRIES;
-            handleScanStarted();
-            tryDiscoverPeers();
+    private void updateScanState() {
+        if (mScanRequested && mWfdEnabled && mDesiredDevice == null) {
+            if (!mDiscoverPeersInProgress) {
+                Slog.i(TAG, "Starting Wifi display scan.");
+                mDiscoverPeersInProgress = true;
+                handleScanStarted();
+                tryDiscoverPeers();
+            }
+        } else {
+            if (mDiscoverPeersInProgress) {
+                // Cancel automatic retry right away.
+                mHandler.removeCallbacks(mDiscoverPeers);
+
+                // Defer actually stopping discovery if we have a connection attempt in progress.
+                // The wifi display connection attempt often fails if we are not in discovery
+                // mode.  So we allow discovery to continue until we give up trying to connect.
+                if (mDesiredDevice == null || mDesiredDevice == mConnectedDevice) {
+                    Slog.i(TAG, "Stopping Wifi display scan.");
+                    mDiscoverPeersInProgress = false;
+                    stopPeerDiscovery();
+                    handleScanFinished();
+                }
+            }
         }
     }
 
@@ -357,8 +392,9 @@
                     Slog.d(TAG, "Discover peers succeeded.  Requesting peers now.");
                 }
 
-                mDiscoverPeersInProgress = false;
-                requestPeers();
+                if (mDiscoverPeersInProgress) {
+                    requestPeers();
+                }
             }
 
             @Override
@@ -367,30 +403,28 @@
                     Slog.d(TAG, "Discover peers failed with reason " + reason + ".");
                 }
 
-                if (mDiscoverPeersInProgress) {
-                    if (reason == 0 && mDiscoverPeersRetriesLeft > 0 && mWfdEnabled) {
-                        mHandler.postDelayed(new Runnable() {
-                            @Override
-                            public void run() {
-                                if (mDiscoverPeersInProgress) {
-                                    if (mDiscoverPeersRetriesLeft > 0 && mWfdEnabled) {
-                                        mDiscoverPeersRetriesLeft -= 1;
-                                        if (DEBUG) {
-                                            Slog.d(TAG, "Retrying discovery.  Retries left: "
-                                                    + mDiscoverPeersRetriesLeft);
-                                        }
-                                        tryDiscoverPeers();
-                                    } else {
-                                        handleScanFinished();
-                                        mDiscoverPeersInProgress = false;
-                                    }
-                                }
-                            }
-                        }, DISCOVER_PEERS_RETRY_DELAY_MILLIS);
-                    } else {
-                        handleScanFinished();
-                        mDiscoverPeersInProgress = false;
-                    }
+                // Ignore the error.
+                // We will retry automatically in a little bit.
+            }
+        });
+
+        // Retry discover peers periodically until stopped.
+        mHandler.postDelayed(mDiscoverPeers, DISCOVER_PEERS_INTERVAL_MILLIS);
+    }
+
+    private void stopPeerDiscovery() {
+        mWifiP2pManager.stopPeerDiscovery(mWifiP2pChannel, new ActionListener() {
+            @Override
+            public void onSuccess() {
+                if (DEBUG) {
+                    Slog.d(TAG, "Stop peer discovery succeeded.");
+                }
+            }
+
+            @Override
+            public void onFailure(int reason) {
+                if (DEBUG) {
+                    Slog.d(TAG, "Stop peer discovery failed with reason " + reason + ".");
                 }
             }
         });
@@ -415,7 +449,9 @@
                     }
                 }
 
-                handleScanFinished();
+                if (mDiscoverPeersInProgress) {
+                    handleScanResults();
+                }
             }
         });
     }
@@ -429,7 +465,7 @@
         });
     }
 
-    private void handleScanFinished() {
+    private void handleScanResults() {
         final int count = mAvailableWifiDisplayPeers.size();
         final WifiDisplay[] displays = WifiDisplay.CREATOR.newArray(count);
         for (int i = 0; i < count; i++) {
@@ -441,7 +477,16 @@
         mHandler.post(new Runnable() {
             @Override
             public void run() {
-                mListener.onScanFinished(displays);
+                mListener.onScanResults(displays);
+            }
+        });
+    }
+
+    private void handleScanFinished() {
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                mListener.onScanFinished();
             }
         });
     }
@@ -484,6 +529,12 @@
             return;
         }
 
+        if (!mWfdEnabled) {
+            Slog.i(TAG, "Ignoring request to connect to Wifi display because the "
+                    +" feature is currently disabled: " + device.deviceName);
+            return;
+        }
+
         mDesiredDevice = device;
         mConnectionRetriesLeft = CONNECT_MAX_RETRIES;
         updateConnection();
@@ -508,6 +559,10 @@
      * connection is established (or not).
      */
     private void updateConnection() {
+        // Step 0. Stop scans if necessary to prevent interference while connected.
+        // Resume scans later when no longer attempting to connect.
+        updateScanState();
+
         // Step 1. Before we try to connect to a new device, tell the system we
         // have disconnected from the old one.
         if (mRemoteDisplay != null && mConnectedDevice != mDesiredDevice) {
@@ -661,7 +716,7 @@
             return; // wait for asynchronous callback
         }
 
-        // Step 6. Listen for incoming connections.
+        // Step 6. Listen for incoming RTSP connection.
         if (mConnectedDevice != null && mRemoteDisplay == null) {
             Inet4Address addr = getInterfaceAddress(mConnectedDeviceGroupInfo);
             if (addr == null) {
@@ -817,7 +872,11 @@
             }
         } else {
             mConnectedDeviceGroupInfo = null;
-            disconnect();
+
+            // Disconnect if we lost the network while connecting or connected to a display.
+            if (mConnectingDevice != null || mConnectedDevice != null) {
+                disconnect();
+            }
 
             // After disconnection for a group, for some reason we have a tendency
             // to get a peer change notification with an empty list of peers.
@@ -828,6 +887,13 @@
         }
     }
 
+    private final Runnable mDiscoverPeers = new Runnable() {
+        @Override
+        public void run() {
+            tryDiscoverPeers();
+        }
+    };
+
     private final Runnable mConnectionTimeout = new Runnable() {
         @Override
         public void run() {
@@ -1033,7 +1099,8 @@
         void onFeatureStateChanged(int featureState);
 
         void onScanStarted();
-        void onScanFinished(WifiDisplay[] availableDisplays);
+        void onScanResults(WifiDisplay[] availableDisplays);
+        void onScanFinished();
 
         void onDisplayConnecting(WifiDisplay display);
         void onDisplayConnectionFailed();
diff --git a/services/java/com/android/server/wm/AppWindowToken.java b/services/java/com/android/server/wm/AppWindowToken.java
index b1d67de..e98014b 100644
--- a/services/java/com/android/server/wm/AppWindowToken.java
+++ b/services/java/com/android/server/wm/AppWindowToken.java
@@ -53,7 +53,7 @@
     int groupId = -1;
     boolean appFullscreen;
     int requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED;
-    int configChanges;
+    boolean layoutConfigChanges;
     boolean showWhenLocked;
 
     // The input dispatching timeout for this application token in nanoseconds.
diff --git a/services/java/com/android/server/wm/TaskStack.java b/services/java/com/android/server/wm/TaskStack.java
index e65aecb..cb29df4 100644
--- a/services/java/com/android/server/wm/TaskStack.java
+++ b/services/java/com/android/server/wm/TaskStack.java
@@ -271,6 +271,8 @@
                 for (int winNdx = windows.size() - 1; winNdx >= 0; --winNdx) {
                     final WindowState win = windows.get(winNdx);
                     if (!resizingWindows.contains(win)) {
+                        if (WindowManagerService.DEBUG_RESIZE) Slog.d(TAG,
+                                "setBounds: Resizing " + win);
                         resizingWindows.add(win);
                     }
                     win.mUnderStatusBar = underStatusBar;
diff --git a/services/java/com/android/server/wm/WindowManagerService.java b/services/java/com/android/server/wm/WindowManagerService.java
index 6d47fcf..f9773a6 100644
--- a/services/java/com/android/server/wm/WindowManagerService.java
+++ b/services/java/com/android/server/wm/WindowManagerService.java
@@ -3439,7 +3439,8 @@
             atoken.appFullscreen = fullscreen;
             atoken.showWhenLocked = showWhenLocked;
             atoken.requestedOrientation = requestedOrientation;
-            atoken.configChanges = configChanges;
+            atoken.layoutConfigChanges = (configChanges &
+                    (ActivityInfo.CONFIG_SCREEN_SIZE | ActivityInfo.CONFIG_ORIENTATION)) != 0;
             if (DEBUG_TOKEN_MOVEMENT || DEBUG_ADD_REMOVE) Slog.v(TAG, "addAppToken: " + atoken
                     + " to stack=" + stackId + " task=" + taskId + " at " + addPos);
 
@@ -8263,10 +8264,9 @@
             // windows, since that means "perform layout as normal,
             // just don't display").
             if (!gone || !win.mHaveFrame || win.mLayoutNeeded
-                    || win.isConfigChanged() && (win.mAttrs.type == TYPE_KEYGUARD ||
-                            (win.mAppToken != null && (win.mAppToken.configChanges &
-                            (ActivityInfo.CONFIG_SCREEN_SIZE | ActivityInfo.CONFIG_ORIENTATION))
-                                    != 0))
+                    || ((win.isConfigChanged() || win.setInsetsChanged()) &&
+                            (win.mAttrs.type == TYPE_KEYGUARD ||
+                            win.mAppToken != null && win.mAppToken.layoutConfigChanges))
                     || win.mAttrs.type == TYPE_UNIVERSE_BACKGROUND) {
                 if (!win.mLayoutAttached) {
                     if (initial) {
@@ -8700,12 +8700,7 @@
     private void updateResizingWindows(final WindowState w) {
         final WindowStateAnimator winAnimator = w.mWinAnimator;
         if (w.mHasSurface && w.mLayoutSeq == mLayoutSeq) {
-            w.mOverscanInsetsChanged |=
-                    !w.mLastOverscanInsets.equals(w.mOverscanInsets);
-            w.mContentInsetsChanged |=
-                    !w.mLastContentInsets.equals(w.mContentInsets);
-            w.mVisibleInsetsChanged |=
-                    !w.mLastVisibleInsets.equals(w.mVisibleInsets);
+            w.setInsetsChanged();
             boolean configChanged = w.isConfigChanged();
             if (DEBUG_CONFIGURATION && configChanged) {
                 Slog.v(TAG, "Win " + w + " config changed: "
diff --git a/services/java/com/android/server/wm/WindowState.java b/services/java/com/android/server/wm/WindowState.java
index 2d08792..4d53cea 100644
--- a/services/java/com/android/server/wm/WindowState.java
+++ b/services/java/com/android/server/wm/WindowState.java
@@ -701,6 +701,13 @@
         return mAppToken != null ? mAppToken.appToken : null;
     }
 
+    boolean setInsetsChanged() {
+        mOverscanInsetsChanged |= !mLastOverscanInsets.equals(mOverscanInsets);
+        mContentInsetsChanged |= !mLastContentInsets.equals(mContentInsets);
+        mVisibleInsetsChanged |= !mLastVisibleInsets.equals(mVisibleInsets);
+        return mOverscanInsetsChanged || mContentInsetsChanged || mVisibleInsetsChanged;
+    }
+
     public int getDisplayId() {
         return mDisplayContent.getDisplayId();
     }
diff --git a/tools/layoutlib/bridge/src/android/graphics/BitmapFactory_Delegate.java b/tools/layoutlib/bridge/src/android/graphics/BitmapFactory_Delegate.java
index 04ce9d0..d85c3d1 100644
--- a/tools/layoutlib/bridge/src/android/graphics/BitmapFactory_Delegate.java
+++ b/tools/layoutlib/bridge/src/android/graphics/BitmapFactory_Delegate.java
@@ -44,62 +44,13 @@
  */
 /*package*/ class BitmapFactory_Delegate {
 
-    // ------ Java delegates ------
-
-    @LayoutlibDelegate
-    /*package*/ static Bitmap finishDecode(Bitmap bm, Rect outPadding, Options opts) {
-        if (bm == null || opts == null) {
-            return bm;
-        }
-
-        final int density = opts.inDensity;
-        if (density == 0) {
-            return bm;
-        }
-
-        bm.setDensity(density);
-        final int targetDensity = opts.inTargetDensity;
-        if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
-            return bm;
-        }
-
-        byte[] np = bm.getNinePatchChunk();
-        final boolean isNinePatch = np != null && NinePatch.isNinePatchChunk(np);
-        // DELEGATE CHANGE: never scale 9-patch
-        if (opts.inScaled && isNinePatch == false) {
-            float scale = targetDensity / (float)density;
-            // TODO: This is very inefficient and should be done in native by Skia
-            final Bitmap oldBitmap = bm;
-            bm = Bitmap.createScaledBitmap(oldBitmap, (int) (bm.getWidth() * scale + 0.5f),
-                    (int) (bm.getHeight() * scale + 0.5f), true);
-            oldBitmap.recycle();
-
-            if (isNinePatch) {
-                np = nativeScaleNinePatch(np, scale, outPadding);
-                bm.setNinePatchChunk(np);
-            }
-            bm.setDensity(targetDensity);
-        }
-
-        return bm;
-    }
-
-
     // ------ Native Delegates ------
 
     @LayoutlibDelegate
     /*package*/ static Bitmap nativeDecodeStream(InputStream is, byte[] storage,
             Rect padding, Options opts) {
-        return nativeDecodeStream(is, storage, padding, opts, false, 1.f);
-    }
-
-    @LayoutlibDelegate
-    /*package*/ static  Bitmap nativeDecodeStream(InputStream is, byte[] storage,
-            Rect padding, Options opts, boolean applyScale, float scale) {
         Bitmap bm = null;
 
-        //TODO support rescaling
-
         Density density = Density.MEDIUM;
         Set<BitmapCreateFlags> bitmapCreateFlags = EnumSet.of(BitmapCreateFlags.MUTABLE);
         if (opts != null) {
@@ -157,13 +108,6 @@
     }
 
     @LayoutlibDelegate
-    /*package*/ static Bitmap nativeDecodeAsset(int asset, Rect padding, Options opts,
-            boolean applyScale, float scale) {
-        opts.inBitmap = null;
-        return null;
-    }
-
-    @LayoutlibDelegate
     /*package*/ static Bitmap nativeDecodeByteArray(byte[] data, int offset,
             int length, Options opts) {
         opts.inBitmap = null;
@@ -171,13 +115,6 @@
     }
 
     @LayoutlibDelegate
-    /*package*/ static byte[] nativeScaleNinePatch(byte[] chunk, float scale, Rect pad) {
-        // don't scale for now. This should not be called anyway since we re-implement
-        // BitmapFactory.finishDecode();
-        return chunk;
-    }
-
-    @LayoutlibDelegate
     /*package*/ static boolean nativeIsSeekable(FileDescriptor fd) {
         return true;
     }
diff --git a/tools/layoutlib/bridge/src/android/graphics/Bitmap_Delegate.java b/tools/layoutlib/bridge/src/android/graphics/Bitmap_Delegate.java
index 93284db..13d2ba1 100644
--- a/tools/layoutlib/bridge/src/android/graphics/Bitmap_Delegate.java
+++ b/tools/layoutlib/bridge/src/android/graphics/Bitmap_Delegate.java
@@ -314,6 +314,13 @@
     }
 
     @LayoutlibDelegate
+    /*package*/ static void nativeReconfigure(int nativeBitmap, int width, int height,
+            int config, int allocSize) {
+        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
+                "Bitmap.reconfigure() is not supported", null /*data*/);
+    }
+
+    @LayoutlibDelegate
     /*package*/ static boolean nativeCompress(int nativeBitmap, int format, int quality,
             OutputStream stream, byte[] tempStorage) {
         Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED,
@@ -342,28 +349,6 @@
     }
 
     @LayoutlibDelegate
-    /*package*/ static int nativeWidth(int nativeBitmap) {
-        // get the delegate from the native int.
-        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
-        if (delegate == null) {
-            return 0;
-        }
-
-        return delegate.mImage.getWidth();
-    }
-
-    @LayoutlibDelegate
-    /*package*/ static int nativeHeight(int nativeBitmap) {
-        // get the delegate from the native int.
-        Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
-        if (delegate == null) {
-            return 0;
-        }
-
-        return delegate.mImage.getHeight();
-    }
-
-    @LayoutlibDelegate
     /*package*/ static int nativeRowBytes(int nativeBitmap) {
         // get the delegate from the native int.
         Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
@@ -408,19 +393,21 @@
     }
 
     @LayoutlibDelegate
-    /*package*/ static int nativeGetPixel(int nativeBitmap, int x, int y) {
+    /*package*/ static int nativeGetPixel(int nativeBitmap, int x, int y,
+            boolean isPremultiplied) {
         // get the delegate from the native int.
         Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
         if (delegate == null) {
             return 0;
         }
 
+        // TODO: Support isPremultiplied.
         return delegate.mImage.getRGB(x, y);
     }
 
     @LayoutlibDelegate
     /*package*/ static void nativeGetPixels(int nativeBitmap, int[] pixels, int offset,
-            int stride, int x, int y, int width, int height) {
+            int stride, int x, int y, int width, int height, boolean isPremultiplied) {
         Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
         if (delegate == null) {
             return;
@@ -431,7 +418,8 @@
 
 
     @LayoutlibDelegate
-    /*package*/ static void nativeSetPixel(int nativeBitmap, int x, int y, int color) {
+    /*package*/ static void nativeSetPixel(int nativeBitmap, int x, int y, int color,
+            boolean isPremultiplied) {
         Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
         if (delegate == null) {
             return;
@@ -442,7 +430,7 @@
 
     @LayoutlibDelegate
     /*package*/ static void nativeSetPixels(int nativeBitmap, int[] colors, int offset,
-            int stride, int x, int y, int width, int height) {
+            int stride, int x, int y, int width, int height, boolean isPremultiplied) {
         Bitmap_Delegate delegate = sManager.getDelegate(nativeBitmap);
         if (delegate == null) {
             return;
diff --git a/tools/layoutlib/bridge/src/android/graphics/NinePatch_Delegate.java b/tools/layoutlib/bridge/src/android/graphics/NinePatch_Delegate.java
index fa68796..b5134630 100644
--- a/tools/layoutlib/bridge/src/android/graphics/NinePatch_Delegate.java
+++ b/tools/layoutlib/bridge/src/android/graphics/NinePatch_Delegate.java
@@ -167,6 +167,7 @@
         return sManager.addNewDelegate(newDelegate);
     }
 
+    @LayoutlibDelegate
     /*package*/ static void nativeFinalize(int chunk) {
         sManager.removeJavaReferenceFor(chunk);
     }
diff --git a/tools/layoutlib/bridge/src/android/graphics/Path_Delegate.java b/tools/layoutlib/bridge/src/android/graphics/Path_Delegate.java
index 64f19d3..9d80be9 100644
--- a/tools/layoutlib/bridge/src/android/graphics/Path_Delegate.java
+++ b/tools/layoutlib/bridge/src/android/graphics/Path_Delegate.java
@@ -474,6 +474,12 @@
     }
 
     @LayoutlibDelegate
+    /*package*/ static boolean native_op(int nPath1, int nPath2, int op, int result) {
+        Bridge.getLog().error(LayoutLog.TAG_UNSUPPORTED, "Path.op() not supported", null);
+        return false;
+    }
+
+    @LayoutlibDelegate
     /*package*/ static void finalizer(int nPath) {
         sManager.removeJavaReferenceFor(nPath);
     }
diff --git a/tools/layoutlib/bridge/src/libcore/icu/DateIntervalFormat_Delegate.java b/tools/layoutlib/bridge/src/libcore/icu/DateIntervalFormat_Delegate.java
index a773d93..d94c205 100644
--- a/tools/layoutlib/bridge/src/libcore/icu/DateIntervalFormat_Delegate.java
+++ b/tools/layoutlib/bridge/src/libcore/icu/DateIntervalFormat_Delegate.java
@@ -21,6 +21,7 @@
 import com.android.ide.common.rendering.api.LayoutLog;
 import com.android.layoutlib.bridge.Bridge;
 import com.android.layoutlib.bridge.impl.DelegateManager;
+import com.android.tools.layoutlib.annotations.LayoutlibDelegate;
 import com.ibm.icu.text.DateIntervalFormat;
 import com.ibm.icu.util.DateInterval;
 import com.ibm.icu.util.TimeZone;
@@ -38,6 +39,7 @@
 
     // ---- native methods ----
 
+    @LayoutlibDelegate
     /*package*/static String formatDateInterval(long address, long fromDate, long toDate) {
         DateIntervalFormat_Delegate delegate = sManager.getDelegate((int)address);
         if (delegate == null) {
@@ -52,6 +54,7 @@
         return sb.toString();
     }
 
+    @LayoutlibDelegate
     /*package*/ static long createDateIntervalFormat(String skeleton, String localeName,
             String tzName) {
         TimeZone prevDefaultTz = TimeZone.getDefault();
@@ -63,6 +66,7 @@
         return sManager.addNewDelegate(newDelegate);
     }
 
+    @LayoutlibDelegate
     /*package*/ static void destroyDateIntervalFormat(long address) {
         sManager.removeJavaReferenceFor((int)address);
     }
diff --git a/tools/layoutlib/bridge/src/libcore/icu/ICU_Delegate.java b/tools/layoutlib/bridge/src/libcore/icu/ICU_Delegate.java
index 06ae804..ad4103b 100644
--- a/tools/layoutlib/bridge/src/libcore/icu/ICU_Delegate.java
+++ b/tools/layoutlib/bridge/src/libcore/icu/ICU_Delegate.java
@@ -46,7 +46,7 @@
     // --- Native methods accessing ICU's database.
 
     @LayoutlibDelegate
-    /*package*/ static String getBestDateTimePattern(String skeleton, String localeName) {
+    /*package*/ static String getBestDateTimePatternNative(String skeleton, String localeName) {
         return DateTimePatternGenerator.getInstance(new ULocale(localeName))
                 .getBestPattern(skeleton);
     }
@@ -167,7 +167,7 @@
     }
 
     @LayoutlibDelegate
-    /*package*/ static boolean initLocaleDataImpl(String locale, LocaleData result) {
+    /*package*/ static boolean initLocaleDataNative(String locale, LocaleData result) {
 
         // Used by Calendar.
         result.firstDayOfWeek = Integer.valueOf(1);
