diff --git a/current/android.jar b/current/android.jar
index 0dcb296..91cc3e5 100644
--- a/current/android.jar
+++ b/current/android.jar
Binary files differ
diff --git a/current/framework.aidl b/current/framework.aidl
index d1b3d97..e25a5e9 100644
--- a/current/framework.aidl
+++ b/current/framework.aidl
@@ -101,6 +101,7 @@
 parcelable android.view.textservice.SpellCheckerInfo;
 parcelable android.view.textservice.SentenceSuggestionsInfo;
 parcelable android.view.textservice.SuggestionsInfo;
+parcelable android.service.carrier.CarrierIdentifier;
 parcelable android.service.carrier.MessagePdu;
 parcelable android.service.notification.StatusBarNotification;
 parcelable android.service.chooser.ChooserTarget;
@@ -109,6 +110,7 @@
 parcelable android.app.AssistStructure;
 parcelable android.app.AssistContent;
 parcelable android.app.Notification;
+parcelable android.app.NotificationManager.Policy;
 parcelable android.app.WallpaperInfo;
 parcelable android.app.AppOpsManager.PackageOps;
 parcelable android.app.ActivityManager.RecentTaskInfo;
diff --git a/current/support/annotations/android-support-annotations.jar b/current/support/annotations/android-support-annotations.jar
index 3a656b9..efbf797 100644
--- a/current/support/annotations/android-support-annotations.jar
+++ b/current/support/annotations/android-support-annotations.jar
Binary files differ
diff --git a/current/support/design/libs/android-support-design.jar b/current/support/design/libs/android-support-design.jar
index 609afcd..d58a9ee 100644
--- a/current/support/design/libs/android-support-design.jar
+++ b/current/support/design/libs/android-support-design.jar
Binary files differ
diff --git a/current/support/design/res/layout/design_navigation_item_space.xml b/current/support/design/res/layout/design_navigation_item_header.xml
similarity index 75%
rename from current/support/design/res/layout/design_navigation_item_space.xml
rename to current/support/design/res/layout/design_navigation_item_header.xml
index 6d709ab..9886007 100644
--- a/current/support/design/res/layout/design_navigation_item_space.xml
+++ b/current/support/design/res/layout/design_navigation_item_header.xml
@@ -14,7 +14,8 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License.
 -->
-<View xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
       android:layout_width="match_parent"
-      android:layout_height="@dimen/navigation_separator_vertical_padding"
-      android:visibility="invisible" />
+      android:layout_height="wrap_content"
+      android:orientation="vertical"
+      android:paddingBottom="@dimen/navigation_separator_vertical_padding" />
diff --git a/current/support/design/res/values/attrs.xml b/current/support/design/res/values/attrs.xml
index c018923..e155e23 100644
--- a/current/support/design/res/values/attrs.xml
+++ b/current/support/design/res/values/attrs.xml
@@ -160,6 +160,11 @@
         <attr name="maxActionInlineWidth" format="dimension"/>
     </declare-styleable>
 
+    <declare-styleable name="AppBarLayout">
+        <attr name="elevation" />
+        <attr name="android:background" />
+    </declare-styleable>
+
     <declare-styleable name="AppBarLayout_LayoutParams">
         <attr name="layout_scrollFlags">
             <!-- The view will be scroll in direct relation to scroll events. This flag needs to be
diff --git a/current/support/design/res/values/dimens.xml b/current/support/design/res/values/dimens.xml
index f3a9111..3c8f77e 100644
--- a/current/support/design/res/values/dimens.xml
+++ b/current/support/design/res/values/dimens.xml
@@ -50,4 +50,6 @@
 
     <dimen name="snackbar_text_size">14sp</dimen>
 
+    <dimen name="appbar_elevation">4dp</dimen>
+
 </resources>
diff --git a/current/support/design/res/values/styles.xml b/current/support/design/res/values/styles.xml
index 572e278..c3fb502 100644
--- a/current/support/design/res/values/styles.xml
+++ b/current/support/design/res/values/styles.xml
@@ -100,5 +100,10 @@
         <item name="foregroundScrimColor">@android:color/transparent</item>
     </style>
 
+    <style name="Widget.Design.AppBarLayout" parent="android:Widget">
+        <item name="elevation">@dimen/appbar_elevation</item>
+        <item name="android:background">?attr/colorPrimary</item>
+    </style>
+
 </resources>
 
diff --git a/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar b/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
index ff04983..47cdc1c 100644
--- a/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
+++ b/current/support/multidex/instrumentation/libs/android-support-multidex-instrumentation.jar
Binary files differ
diff --git a/current/support/multidex/library/libs/android-support-multidex.jar b/current/support/multidex/library/libs/android-support-multidex.jar
index 5c3a833..15b054e 100644
--- a/current/support/multidex/library/libs/android-support-multidex.jar
+++ b/current/support/multidex/library/libs/android-support-multidex.jar
Binary files differ
diff --git a/current/support/v13/android-support-v13.jar b/current/support/v13/android-support-v13.jar
index 01b2d08..e316ad8 100644
--- a/current/support/v13/android-support-v13.jar
+++ b/current/support/v13/android-support-v13.jar
Binary files differ
diff --git a/current/support/v17/leanback/libs/android-support-v17-leanback.jar b/current/support/v17/leanback/libs/android-support-v17-leanback.jar
index 787e5ef..202954c 100644
--- a/current/support/v17/leanback/libs/android-support-v17-leanback.jar
+++ b/current/support/v17/leanback/libs/android-support-v17-leanback.jar
Binary files differ
diff --git a/current/support/v4/android-support-v4.jar b/current/support/v4/android-support-v4.jar
index 34c70fe..d80b348 100644
--- a/current/support/v4/android-support-v4.jar
+++ b/current/support/v4/android-support-v4.jar
Binary files differ
diff --git a/current/support/v4/src/api/current.txt b/current/support/v4/src/api/current.txt
index 7609df0..829616f 100644
--- a/current/support/v4/src/api/current.txt
+++ b/current/support/v4/src/api/current.txt
@@ -114,10 +114,11 @@
     method public boolean getAllowReturnTransitionOverlap();
     method public final android.os.Bundle getArguments();
     method public final android.support.v4.app.FragmentManager getChildFragmentManager();
-    method public final android.content.Context getContext();
+    method public android.content.Context getContext();
     method public java.lang.Object getEnterTransition();
     method public java.lang.Object getExitTransition();
     method public final android.support.v4.app.FragmentManager getFragmentManager();
+    method public final java.lang.Object getHost();
     method public final int getId();
     method public android.support.v4.app.LoaderManager getLoaderManager();
     method public final android.support.v4.app.Fragment getParentFragment();
@@ -233,7 +234,7 @@
 
   public class FragmentController {
     method public void attachHost(android.support.v4.app.Fragment);
-    method public static final android.support.v4.app.FragmentController createController(android.support.v4.app.FragmentHostCallbacks);
+    method public static final android.support.v4.app.FragmentController createController(android.support.v4.app.FragmentHostCallbacks<?>);
     method public void dispatchActivityCreated();
     method public void dispatchConfigurationChanged(android.content.res.Configuration);
     method public boolean dispatchContextItemSelected(android.view.MenuItem);
@@ -250,6 +251,10 @@
     method public void dispatchResume();
     method public void dispatchStart();
     method public void dispatchStop();
+    method public void doLoaderDestroy();
+    method public void doLoaderRetain();
+    method public void doLoaderStart();
+    method public void doLoaderStop(boolean);
     method public void dumpLoaders(java.lang.String, java.io.FileDescriptor, java.io.PrintWriter, java.lang.String[]);
     method public boolean execPendingActions();
     method public java.util.List<android.support.v4.app.Fragment> getActiveFragments(java.util.List<android.support.v4.app.Fragment>);
@@ -258,6 +263,7 @@
     method public android.support.v4.app.LoaderManager getSupportLoaderManager();
     method public void noteStateNotSaved();
     method public android.view.View onCreateView(android.view.View, java.lang.String, android.content.Context, android.util.AttributeSet);
+    method public void reportLoaderStart();
     method public void restoreAllState(android.os.Parcelable, java.util.ArrayList<android.support.v4.app.Fragment>);
     method public void restoreLoaderNonConfig(android.support.v4.util.SimpleArrayMap<java.lang.String, android.support.v4.app.LoaderManager>);
     method public android.support.v4.util.SimpleArrayMap<java.lang.String, android.support.v4.app.LoaderManager> retainLoaderNonConfig();
@@ -269,6 +275,7 @@
     ctor public FragmentHostCallbacks(android.content.Context, android.os.Handler, int);
     method public void dump(java.lang.String, java.io.FileDescriptor, java.io.PrintWriter, java.lang.String[]);
     method public android.view.View findViewById(int);
+    method public E getHost();
     method public android.view.LayoutInflater getLayoutInflater();
     method public int getWindowAnimations();
     method public boolean hasView();
@@ -491,11 +498,11 @@
 
   public static class NotificationCompat.Action extends android.support.v4.app.NotificationCompatBase.Action {
     ctor public NotificationCompat.Action(int, java.lang.CharSequence, android.app.PendingIntent);
-    method protected android.app.PendingIntent getActionIntent();
+    method public android.app.PendingIntent getActionIntent();
     method public android.os.Bundle getExtras();
-    method protected int getIcon();
+    method public int getIcon();
     method public android.support.v4.app.RemoteInput[] getRemoteInputs();
-    method protected java.lang.CharSequence getTitle();
+    method public java.lang.CharSequence getTitle();
     field public android.app.PendingIntent actionIntent;
     field public int icon;
     field public java.lang.CharSequence title;
@@ -699,16 +706,17 @@
     field public static final int UNSET_ACTION_INDEX = -1; // 0xffffffff
   }
 
-   class NotificationCompatBase {
+  public class NotificationCompatBase {
+    ctor public NotificationCompatBase();
   }
 
   public static abstract class NotificationCompatBase.Action {
     ctor public NotificationCompatBase.Action();
-    method protected abstract android.app.PendingIntent getActionIntent();
-    method protected abstract android.os.Bundle getExtras();
-    method protected abstract int getIcon();
-    method protected abstract android.support.v4.app.RemoteInputCompatBase.RemoteInput[] getRemoteInputs();
-    method protected abstract java.lang.CharSequence getTitle();
+    method public abstract android.app.PendingIntent getActionIntent();
+    method public abstract android.os.Bundle getExtras();
+    method public abstract int getIcon();
+    method public abstract android.support.v4.app.RemoteInputCompatBase.RemoteInput[] getRemoteInputs();
+    method public abstract java.lang.CharSequence getTitle();
   }
 
   public static abstract class NotificationCompatBase.UnreadConversation {
@@ -2446,6 +2454,8 @@
     method public android.support.v4.view.ViewPropertyAnimatorCompat translationXBy(float);
     method public android.support.v4.view.ViewPropertyAnimatorCompat translationY(float);
     method public android.support.v4.view.ViewPropertyAnimatorCompat translationYBy(float);
+    method public android.support.v4.view.ViewPropertyAnimatorCompat translationZ(float);
+    method public android.support.v4.view.ViewPropertyAnimatorCompat translationZBy(float);
     method public android.support.v4.view.ViewPropertyAnimatorCompat withEndAction(java.lang.Runnable);
     method public android.support.v4.view.ViewPropertyAnimatorCompat withLayer();
     method public android.support.v4.view.ViewPropertyAnimatorCompat withStartAction(java.lang.Runnable);
@@ -2453,6 +2463,8 @@
     method public android.support.v4.view.ViewPropertyAnimatorCompat xBy(float);
     method public android.support.v4.view.ViewPropertyAnimatorCompat y(float);
     method public android.support.v4.view.ViewPropertyAnimatorCompat yBy(float);
+    method public android.support.v4.view.ViewPropertyAnimatorCompat z(float);
+    method public android.support.v4.view.ViewPropertyAnimatorCompat zBy(float);
   }
 
   public abstract interface ViewPropertyAnimatorListener {
@@ -2984,7 +2996,9 @@
 
   public class PopupWindowCompat {
     method public static boolean getOverlapAnchor(android.widget.PopupWindow);
+    method public static int getWindowLayoutType(android.widget.PopupWindow);
     method public static void setOverlapAnchor(android.widget.PopupWindow, boolean);
+    method public static void setWindowLayoutType(android.widget.PopupWindow, int);
     method public static void showAsDropDown(android.widget.PopupWindow, android.view.View, int, int, int);
   }
 
diff --git a/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar b/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
index b67e5da..f0882e0 100644
--- a/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
+++ b/current/support/v7/appcompat/libs/android-support-v7-appcompat.jar
Binary files differ
diff --git a/current/support/v7/appcompat/res/layout-v11/abc_screen_content_include.xml b/current/support/v7/appcompat/res/layout-v11/abc_screen_content_include.xml
deleted file mode 100644
index 757be1c..0000000
--- a/current/support/v7/appcompat/res/layout-v11/abc_screen_content_include.xml
+++ /dev/null
@@ -1,26 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2014 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<merge xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <android.support.v7.internal.widget.NativeActionModeAwareLayout
-            android:id="@id/action_bar_activity_content"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent"
-            android:foregroundGravity="fill_horizontal|top"
-            android:foreground="?android:attr/windowContentOverlay" />
-
-</merge>
diff --git a/current/support/v7/appcompat/res/layout/abc_action_mode_bar.xml b/current/support/v7/appcompat/res/layout/abc_action_mode_bar.xml
index 6af12ea..34b56a1 100644
--- a/current/support/v7/appcompat/res/layout/abc_action_mode_bar.xml
+++ b/current/support/v7/appcompat/res/layout/abc_action_mode_bar.xml
@@ -21,4 +21,5 @@
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:visibility="gone"
+        android:theme="?attr/actionBarTheme"
         style="?attr/actionModeStyle"/>
diff --git a/current/support/v7/appcompat/res/layout/abc_screen_toolbar.xml b/current/support/v7/appcompat/res/layout/abc_screen_toolbar.xml
index 20e0c0e..572ec34 100644
--- a/current/support/v7/appcompat/res/layout/abc_screen_toolbar.xml
+++ b/current/support/v7/appcompat/res/layout/abc_screen_toolbar.xml
@@ -45,6 +45,7 @@
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
                 android:visibility="gone"
+                android:theme="?attr/actionBarTheme"
                 style="?attr/actionModeStyle"/>
 
     </android.support.v7.internal.widget.ActionBarContainer>
diff --git a/current/support/v7/appcompat/res/layout/notification_media_action.xml b/current/support/v7/appcompat/res/layout/notification_media_action.xml
new file mode 100644
index 0000000..d546792
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_media_action.xml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2012 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
+    style="?android:attr/borderlessButtonStyle"
+    android:id="@+id/action0"
+    android:layout_width="48dp"
+    android:layout_height="match_parent"
+    android:layout_marginLeft="2dp"
+    android:layout_marginRight="2dp"
+    android:layout_weight="1"
+    android:gravity="center"/>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml b/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml
new file mode 100644
index 0000000..e31d891
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_media_cancel_action.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<ImageButton xmlns:android="http://schemas.android.com/apk/res/android"
+    style="?android:attr/borderlessButtonStyle"
+    android:id="@+id/cancel_action"
+    android:layout_width="48dp"
+    android:layout_height="match_parent"
+    android:layout_marginLeft="2dp"
+    android:layout_marginRight="2dp"
+    android:layout_weight="1"
+    android:src="@drawable/abc_ic_clear_mtrl_alpha"
+    android:gravity="center"
+    android:visibility="gone"/>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/layout/notification_template_big_media.xml b/current/support/v7/appcompat/res/layout/notification_template_big_media.xml
new file mode 100644
index 0000000..2e40b69
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_big_media.xml
@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/status_bar_latest_event_content"
+    android:layout_width="match_parent"
+    android:layout_height="128dp"
+    >
+    <ImageView android:id="@+id/icon"
+        android:layout_width="@dimen/notification_large_icon_width"
+        android:layout_height="@dimen/notification_large_icon_height"
+        android:scaleType="centerCrop"
+        />
+    <include layout="@layout/notification_media_cancel_action"
+        android:layout_width="48dp"
+        android:layout_height="48dp"
+        android:layout_marginLeft="2dp"
+        android:layout_marginRight="2dp"
+        android:layout_alignParentRight="true"/>
+    <include layout="@layout/notification_template_lines"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="fill_vertical"
+        android:layout_marginLeft="@dimen/notification_large_icon_width"
+        android:layout_marginStart="@dimen/notification_large_icon_width"
+        android:layout_toLeftOf="@id/cancel_action"
+        android:layout_toStartOf="@id/cancel_action"/>
+    <LinearLayout
+        android:id="@+id/media_actions"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        android:layout_alignParentBottom="true"
+        android:layout_marginLeft="12dp"
+        android:layout_marginRight="12dp"
+        android:orientation="horizontal"
+        android:layoutDirection="ltr"
+        >
+        <!-- media buttons will be added here -->
+    </LinearLayout>
+    <ImageView
+        android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:layout_above="@id/media_actions"
+        android:id="@+id/action_divider"
+        android:background="?android:attr/dividerHorizontal" />
+</RelativeLayout>
diff --git a/current/support/v7/appcompat/res/layout/notification_template_big_media_narrow.xml b/current/support/v7/appcompat/res/layout/notification_template_big_media_narrow.xml
new file mode 100644
index 0000000..cf64061
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_big_media_narrow.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<!-- Layout to be used with only max 3 actions. It has a much larger picture at the left side-->
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/status_bar_latest_event_content"
+    android:layout_width="match_parent"
+    android:layout_height="128dp"
+    >
+    <ImageView android:id="@+id/icon"
+        android:layout_width="128dp"
+        android:layout_height="128dp"
+        android:scaleType="centerCrop"
+        />
+
+    <include layout="@layout/notification_media_cancel_action"
+        android:layout_width="48dp"
+        android:layout_height="48dp"
+        android:layout_marginLeft="2dp"
+        android:layout_marginRight="2dp"
+        android:layout_alignParentRight="true"
+        android:layout_alignParentEnd="true"/>
+
+    <include layout="@layout/notification_template_lines"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginLeft="128dp"
+        android:layout_marginStart="128dp"
+        android:layout_toLeftOf="@id/cancel_action"
+        android:layout_toStartOf="@id/cancel_action"/>
+
+    <LinearLayout
+        android:id="@+id/media_actions"
+        android:layout_width="match_parent"
+        android:layout_height="48dp"
+        android:layout_toRightOf="@id/icon"
+        android:layout_toEndOf="@id/icon"
+        android:layout_alignParentBottom="true"
+        android:layout_marginLeft="12dp"
+        android:layout_marginRight="12dp"
+        android:orientation="horizontal"
+        android:layoutDirection="ltr"
+        >
+        <!-- media buttons will be added here -->
+    </LinearLayout>
+    <ImageView
+        android:layout_width="match_parent"
+        android:layout_height="1dp"
+        android:layout_toRightOf="@id/icon"
+        android:layout_toEndOf="@id/icon"
+        android:layout_above="@id/media_actions"
+        android:id="@+id/action_divider"
+        android:background="?android:attr/dividerHorizontal" />
+</RelativeLayout>
diff --git a/current/support/v7/appcompat/res/layout/notification_template_lines.xml b/current/support/v7/appcompat/res/layout/notification_template_lines.xml
new file mode 100644
index 0000000..42ba776
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_lines.xml
@@ -0,0 +1,108 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:orientation="vertical"
+    android:paddingRight="8dp"
+    android:paddingEnd="8dp"
+    android:paddingTop="2dp"
+    android:paddingBottom="2dp"
+    >
+    <LinearLayout
+        android:id="@+id/line1"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:paddingTop="6dp"
+        android:layout_marginLeft="8dp"
+        android:layout_marginStart="8dp"
+        android:orientation="horizontal"
+        >
+        <TextView android:id="@+id/title"
+            android:textAppearance="@style/TextAppearance.StatusBar.EventContent.Title"
+            android:layout_width="fill_parent"
+            android:layout_height="wrap_content"
+            android:singleLine="true"
+            android:ellipsize="marquee"
+            android:fadingEdge="horizontal"
+            android:layout_weight="1"
+            />
+        <include
+            layout="@layout/notification_template_part_time"
+            android:id="@+id/time"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center"
+            android:layout_weight="0"
+            android:visibility="gone"
+            />
+        <include
+            layout="@layout/notification_template_part_chronometer"
+            android:id="@+id/chronometer"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center"
+            android:layout_weight="0"
+            android:visibility="gone"
+            />
+    </LinearLayout>
+    <TextView android:id="@+id/text2"
+        android:textAppearance="@style/TextAppearance.StatusBar.EventContent.Line2"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="-2dp"
+        android:layout_marginBottom="-2dp"
+        android:layout_marginLeft="8dp"
+        android:layout_marginStart="8dp"
+        android:singleLine="true"
+        android:fadingEdge="horizontal"
+        android:ellipsize="marquee"
+        android:visibility="gone"
+        />
+    <LinearLayout
+        android:id="@+id/line3"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center_vertical"
+        android:layout_marginLeft="8dp"
+        android:layout_marginStart="8dp"
+        >
+        <TextView android:id="@+id/text"
+            android:textAppearance="@style/TextAppearance.StatusBar.EventContent"
+            android:layout_width="0dp"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:layout_gravity="center"
+            android:singleLine="true"
+            android:ellipsize="marquee"
+            android:fadingEdge="horizontal"
+            />
+        <TextView android:id="@+id/info"
+            android:textAppearance="@style/TextAppearance.StatusBar.EventContent.Info"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="center"
+            android:layout_weight="0"
+            android:singleLine="true"
+            android:gravity="center"
+            android:paddingLeft="8dp"
+            android:paddingStart="8dp"
+            />
+    </LinearLayout>
+</LinearLayout>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/layout/notification_template_media.xml b/current/support/v7/appcompat/res/layout/notification_template_media.xml
new file mode 100644
index 0000000..90daa88
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_media.xml
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/status_bar_latest_event_content"
+    android:layout_width="match_parent"
+    android:layout_height="64dp"
+    android:orientation="horizontal"
+    >
+    <ImageView android:id="@+id/icon"
+        android:layout_width="@dimen/notification_large_icon_width"
+        android:layout_height="@dimen/notification_large_icon_width"
+        android:scaleType="centerCrop"
+        />
+    <include layout="@layout/notification_template_lines"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:layout_weight="1"/>
+    <LinearLayout
+        android:id="@+id/media_actions"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        android:layout_gravity="center_vertical|end"
+        android:orientation="horizontal"
+        android:layoutDirection="ltr"
+        >
+        <!-- media buttons will be added here -->
+    </LinearLayout>
+    <include layout="@layout/notification_media_cancel_action"
+        android:layout_width="48dp"
+        android:layout_height="match_parent"
+        android:layout_marginRight="6dp"
+        android:layout_marginEnd="6dp"/>
+    <ImageView android:id="@+id/end_padder"
+        android:layout_width="6dp"
+        android:layout_height="match_parent"
+        />
+</LinearLayout>
diff --git a/current/support/v7/appcompat/res/layout/notification_template_part_chronometer.xml b/current/support/v7/appcompat/res/layout/notification_template_part_chronometer.xml
new file mode 100644
index 0000000..6f5f3ac
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_part_chronometer.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<Chronometer android:id="@+id/chronometer" xmlns:android="http://schemas.android.com/apk/res/android"
+    android:textAppearance="@style/TextAppearance.StatusBar.EventContent.Time"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:layout_weight="0"
+    android:singleLine="true"
+    android:gravity="center"
+    android:paddingLeft="8dp"
+    android:paddingStart="8dp"
+    />
diff --git a/current/support/v7/appcompat/res/layout/notification_template_part_time.xml b/current/support/v7/appcompat/res/layout/notification_template_part_time.xml
new file mode 100644
index 0000000..72d216e
--- /dev/null
+++ b/current/support/v7/appcompat/res/layout/notification_template_part_time.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<DateTimeView android:id="@+id/time" xmlns:android="http://schemas.android.com/apk/res/android"
+    android:textAppearance="@style/TextAppearance.StatusBar.EventContent.Time"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:layout_weight="0"
+    android:singleLine="true"
+    android:gravity="center"
+    android:paddingLeft="8dp"
+    android:paddingStart="8dp"
+    />
diff --git a/current/support/v7/appcompat/res/values-af/strings.xml b/current/support/v7/appcompat/res/values-af/strings.xml
index 549ab76..4bb50b0 100644
--- a/current/support/v7/appcompat/res/values-af/strings.xml
+++ b/current/support/v7/appcompat/res/values-af/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Sien alles"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Deel met %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Deel met"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-am/strings.xml b/current/support/v7/appcompat/res/values-am/strings.xml
index 9bcea17..a76c931 100644
--- a/current/support/v7/appcompat/res/values-am/strings.xml
+++ b/current/support/v7/appcompat/res/values-am/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ሁሉንም ይመልከቱ"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"ከ%s ጋር ያጋሩ"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"ከሚከተለው ጋር ያጋሩ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ar/strings.xml b/current/support/v7/appcompat/res/values-ar/strings.xml
index 4ed5f59..f0046a9 100644
--- a/current/support/v7/appcompat/res/values-ar/strings.xml
+++ b/current/support/v7/appcompat/res/values-ar/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"عرض الكل"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"‏مشاركة مع %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"مشاركة مع"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"+999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-bg/strings.xml b/current/support/v7/appcompat/res/values-bg/strings.xml
index 74963a2..d8cbcd0 100644
--- a/current/support/v7/appcompat/res/values-bg/strings.xml
+++ b/current/support/v7/appcompat/res/values-bg/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Вижте всички"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Споделяне със: %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Споделяне със:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-bn-rBD/strings.xml b/current/support/v7/appcompat/res/values-bn-rBD/strings.xml
index 93a5997..872d425 100644
--- a/current/support/v7/appcompat/res/values-bn-rBD/strings.xml
+++ b/current/support/v7/appcompat/res/values-bn-rBD/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"সবগুলো দেখুন"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s এর সাথে ভাগ করুন"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"এর সাথে ভাগ করুন"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"৯৯৯+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ca/strings.xml b/current/support/v7/appcompat/res/values-ca/strings.xml
index 97789f5..863e69f 100644
--- a/current/support/v7/appcompat/res/values-ca/strings.xml
+++ b/current/support/v7/appcompat/res/values-ca/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Mostra\'ls tots"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Comparteix amb %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Comparteix amb"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"+999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-cs/strings.xml b/current/support/v7/appcompat/res/values-cs/strings.xml
index 9c3b2b0..cba91eb 100644
--- a/current/support/v7/appcompat/res/values-cs/strings.xml
+++ b/current/support/v7/appcompat/res/values-cs/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Zobrazit vše"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Sdílet pomocí %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Sdílet pomocí"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-da/strings.xml b/current/support/v7/appcompat/res/values-da/strings.xml
index fda0c24..bda4579 100644
--- a/current/support/v7/appcompat/res/values-da/strings.xml
+++ b/current/support/v7/appcompat/res/values-da/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Se alle"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Del med %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Del med"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-de/strings.xml b/current/support/v7/appcompat/res/values-de/strings.xml
index 2905d60..b5a74e9 100644
--- a/current/support/v7/appcompat/res/values-de/strings.xml
+++ b/current/support/v7/appcompat/res/values-de/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Alle ansehen"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Freigeben für %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Freigeben für"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-el/strings.xml b/current/support/v7/appcompat/res/values-el/strings.xml
index 779c83f..1ecc119 100644
--- a/current/support/v7/appcompat/res/values-el/strings.xml
+++ b/current/support/v7/appcompat/res/values-el/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Προβολή όλων"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Κοινή χρήση με %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Κοινή χρήση με"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-en-rAU/strings.xml b/current/support/v7/appcompat/res/values-en-rAU/strings.xml
index a85156e..4db58a9 100644
--- a/current/support/v7/appcompat/res/values-en-rAU/strings.xml
+++ b/current/support/v7/appcompat/res/values-en-rAU/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"See all"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Share with %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Share with"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-en-rGB/strings.xml b/current/support/v7/appcompat/res/values-en-rGB/strings.xml
index a85156e..4db58a9 100644
--- a/current/support/v7/appcompat/res/values-en-rGB/strings.xml
+++ b/current/support/v7/appcompat/res/values-en-rGB/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"See all"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Share with %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Share with"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-en-rIN/strings.xml b/current/support/v7/appcompat/res/values-en-rIN/strings.xml
index a85156e..4db58a9 100644
--- a/current/support/v7/appcompat/res/values-en-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-en-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"See all"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Share with %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Share with"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-es-rUS/strings.xml b/current/support/v7/appcompat/res/values-es-rUS/strings.xml
index b8488e1..043c6ae 100644
--- a/current/support/v7/appcompat/res/values-es-rUS/strings.xml
+++ b/current/support/v7/appcompat/res/values-es-rUS/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver todo"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartir con %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Compartir con"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-es/strings.xml b/current/support/v7/appcompat/res/values-es/strings.xml
index 70ea32d..8f6ea4b 100644
--- a/current/support/v7/appcompat/res/values-es/strings.xml
+++ b/current/support/v7/appcompat/res/values-es/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver todo"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartir con %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Compartir con"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"+999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-et-rEE/strings.xml b/current/support/v7/appcompat/res/values-et-rEE/strings.xml
index cf4deac..b8c7f16 100644
--- a/current/support/v7/appcompat/res/values-et-rEE/strings.xml
+++ b/current/support/v7/appcompat/res/values-et-rEE/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Kuva kõik"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Jagamine kasutajaga %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Jagamine:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-eu-rES/strings.xml b/current/support/v7/appcompat/res/values-eu-rES/strings.xml
index dddc924..3b0fb90 100644
--- a/current/support/v7/appcompat/res/values-eu-rES/strings.xml
+++ b/current/support/v7/appcompat/res/values-eu-rES/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ikusi guztiak"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Partekatu %s erabiltzailearekin"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Partekatu hauekin"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-fa/strings.xml b/current/support/v7/appcompat/res/values-fa/strings.xml
index 3e85c47..ae4eb85 100644
--- a/current/support/v7/appcompat/res/values-fa/strings.xml
+++ b/current/support/v7/appcompat/res/values-fa/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"مشاهده همه"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"‏اشتراک‌گذاری با %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"اشتراک‌گذاری با"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"۹۹۹+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-fi/strings.xml b/current/support/v7/appcompat/res/values-fi/strings.xml
index f706ebe..4b3e728 100644
--- a/current/support/v7/appcompat/res/values-fi/strings.xml
+++ b/current/support/v7/appcompat/res/values-fi/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Näytä kaikki"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Jakaminen: %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Jakaminen:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-fr-rCA/strings.xml b/current/support/v7/appcompat/res/values-fr-rCA/strings.xml
index 98ca75e..291bd4e 100644
--- a/current/support/v7/appcompat/res/values-fr-rCA/strings.xml
+++ b/current/support/v7/appcompat/res/values-fr-rCA/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Voir toutes les chaînes"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Partager avec %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Partager"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-fr/strings.xml b/current/support/v7/appcompat/res/values-fr/strings.xml
index df851d3..b7f5604 100644
--- a/current/support/v7/appcompat/res/values-fr/strings.xml
+++ b/current/support/v7/appcompat/res/values-fr/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Tout afficher"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Partager avec %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Partager avec"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-gl-rES/strings.xml b/current/support/v7/appcompat/res/values-gl-rES/strings.xml
index 618aec0..b6b11be 100644
--- a/current/support/v7/appcompat/res/values-gl-rES/strings.xml
+++ b/current/support/v7/appcompat/res/values-gl-rES/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver todas"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartir con %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Compartir con"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-hi/strings.xml b/current/support/v7/appcompat/res/values-hi/strings.xml
index 2ee69d9..95daa34 100644
--- a/current/support/v7/appcompat/res/values-hi/strings.xml
+++ b/current/support/v7/appcompat/res/values-hi/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"सभी देखें"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s के साथ साझा करें"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"इसके द्वारा साझा करें"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-hr/strings.xml b/current/support/v7/appcompat/res/values-hr/strings.xml
index 7e8968f..da68332 100644
--- a/current/support/v7/appcompat/res/values-hr/strings.xml
+++ b/current/support/v7/appcompat/res/values-hr/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Prikaži sve"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Dijeljenje sa: %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Dijeljenje sa"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-hu/strings.xml b/current/support/v7/appcompat/res/values-hu/strings.xml
index 7fe27d2..57ab85b 100644
--- a/current/support/v7/appcompat/res/values-hu/strings.xml
+++ b/current/support/v7/appcompat/res/values-hu/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Összes megtekintése"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Megosztás a következővel: %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Megosztás a következővel:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-hy-rAM/strings.xml b/current/support/v7/appcompat/res/values-hy-rAM/strings.xml
index 47c29a5..903fa43 100644
--- a/current/support/v7/appcompat/res/values-hy-rAM/strings.xml
+++ b/current/support/v7/appcompat/res/values-hy-rAM/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Տեսնել բոլորը"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Տարածել ըստ %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Տարածել"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-in/strings.xml b/current/support/v7/appcompat/res/values-in/strings.xml
index d102ba6..0e7003c 100644
--- a/current/support/v7/appcompat/res/values-in/strings.xml
+++ b/current/support/v7/appcompat/res/values-in/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Lihat semua"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Bagikan dengan %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Bagikan dengan"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-is-rIS/strings.xml b/current/support/v7/appcompat/res/values-is-rIS/strings.xml
index a205e8b..fb305b2 100644
--- a/current/support/v7/appcompat/res/values-is-rIS/strings.xml
+++ b/current/support/v7/appcompat/res/values-is-rIS/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Sjá allt"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Deila með %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Deila með"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-it/strings.xml b/current/support/v7/appcompat/res/values-it/strings.xml
index 71cb54f..a2d9bee 100644
--- a/current/support/v7/appcompat/res/values-it/strings.xml
+++ b/current/support/v7/appcompat/res/values-it/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Visualizza tutte"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Condividi con %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Condividi con"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-iw/strings.xml b/current/support/v7/appcompat/res/values-iw/strings.xml
index c5ef730..329d0ec 100644
--- a/current/support/v7/appcompat/res/values-iw/strings.xml
+++ b/current/support/v7/appcompat/res/values-iw/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ראה הכל"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"‏שתף עם %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"שתף עם"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"‎999+‎"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ja/strings.xml b/current/support/v7/appcompat/res/values-ja/strings.xml
index 736d454..fa55b08 100644
--- a/current/support/v7/appcompat/res/values-ja/strings.xml
+++ b/current/support/v7/appcompat/res/values-ja/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"すべて表示"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%sと共有"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"共有"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ka-rGE/strings.xml b/current/support/v7/appcompat/res/values-ka-rGE/strings.xml
index 2341e3d..b14bcb7 100644
--- a/current/support/v7/appcompat/res/values-ka-rGE/strings.xml
+++ b/current/support/v7/appcompat/res/values-ka-rGE/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ყველას ნახვა"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s-თან გაზიარება"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"გაზიარება:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-kk-rKZ/strings.xml b/current/support/v7/appcompat/res/values-kk-rKZ/strings.xml
index 1af9a5f..52b9af5 100644
--- a/current/support/v7/appcompat/res/values-kk-rKZ/strings.xml
+++ b/current/support/v7/appcompat/res/values-kk-rKZ/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Барлығын көру"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s бөлісу"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Бөлісу"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-km-rKH/strings.xml b/current/support/v7/appcompat/res/values-km-rKH/strings.xml
index 5fda61a..aa81b7d 100644
--- a/current/support/v7/appcompat/res/values-km-rKH/strings.xml
+++ b/current/support/v7/appcompat/res/values-km-rKH/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"មើល​ទាំងអស់"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"ចែករំលែក​ជាមួយ %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"ចែករំលែក​ជាមួយ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-kn-rIN/strings.xml b/current/support/v7/appcompat/res/values-kn-rIN/strings.xml
index 669c21c..7ef7572 100644
--- a/current/support/v7/appcompat/res/values-kn-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-kn-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ಎಲ್ಲವನ್ನೂ ನೋಡಿ"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s ಜೊತೆಗೆ ಹಂಚಿಕೊಳ್ಳಿ"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"ಇವರೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಿ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ko/strings.xml b/current/support/v7/appcompat/res/values-ko/strings.xml
index ad83225..7c158f9 100644
--- a/current/support/v7/appcompat/res/values-ko/strings.xml
+++ b/current/support/v7/appcompat/res/values-ko/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"전체 보기"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s와(과) 공유"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"공유 대상"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ky-rKG/strings.xml b/current/support/v7/appcompat/res/values-ky-rKG/strings.xml
index b9f0bb1..a758b96 100644
--- a/current/support/v7/appcompat/res/values-ky-rKG/strings.xml
+++ b/current/support/v7/appcompat/res/values-ky-rKG/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Бардыгын көрүү"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s аркылуу бөлүшүү"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Бөлүшүү"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-lo-rLA/strings.xml b/current/support/v7/appcompat/res/values-lo-rLA/strings.xml
index 45f830f..3b93232 100644
--- a/current/support/v7/appcompat/res/values-lo-rLA/strings.xml
+++ b/current/support/v7/appcompat/res/values-lo-rLA/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ເບິ່ງທັງຫມົດ"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"ແບ່ງ​ປັນ​ກັບ​ %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"ແບ່ງປັນກັບ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-lt/strings.xml b/current/support/v7/appcompat/res/values-lt/strings.xml
index 27713a7..b070a2f 100644
--- a/current/support/v7/appcompat/res/values-lt/strings.xml
+++ b/current/support/v7/appcompat/res/values-lt/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Peržiūrėti viską"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Bendrinti naudojant „%s“"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Bendrinti naudojant"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-lv/strings.xml b/current/support/v7/appcompat/res/values-lv/strings.xml
index 986e8eb..7c4ef4f 100644
--- a/current/support/v7/appcompat/res/values-lv/strings.xml
+++ b/current/support/v7/appcompat/res/values-lv/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Skatīt visu"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Kopīgot ar %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Kopīgot ar:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-mk-rMK/strings.xml b/current/support/v7/appcompat/res/values-mk-rMK/strings.xml
index 916809a..ac2b03e 100644
--- a/current/support/v7/appcompat/res/values-mk-rMK/strings.xml
+++ b/current/support/v7/appcompat/res/values-mk-rMK/strings.xml
@@ -37,4 +37,5 @@
     <!-- no translation found for abc_shareactionprovider_share_with_application (7165123711973476752) -->
     <skip />
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Сподели со"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ml-rIN/strings.xml b/current/support/v7/appcompat/res/values-ml-rIN/strings.xml
index c122ed5..53f8e4b 100644
--- a/current/support/v7/appcompat/res/values-ml-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-ml-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"എല്ലാം കാണുക"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s എന്നതുമായി പങ്കിടുക"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"ഇവരുമായി പങ്കിടുക"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-mn-rMN/strings.xml b/current/support/v7/appcompat/res/values-mn-rMN/strings.xml
index eadbb9f..a89dc4d 100644
--- a/current/support/v7/appcompat/res/values-mn-rMN/strings.xml
+++ b/current/support/v7/appcompat/res/values-mn-rMN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Бүгдийг харах"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s-тай хуваалцах"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Хуваалцах"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-mr-rIN/strings.xml b/current/support/v7/appcompat/res/values-mr-rIN/strings.xml
index a2fb945..1afbd81 100644
--- a/current/support/v7/appcompat/res/values-mr-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-mr-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"सर्व पहा"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s सह सामायिक करा"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"यांच्यासह सामायिक करा"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ms-rMY/strings.xml b/current/support/v7/appcompat/res/values-ms-rMY/strings.xml
index f42fe3d..9763618 100644
--- a/current/support/v7/appcompat/res/values-ms-rMY/strings.xml
+++ b/current/support/v7/appcompat/res/values-ms-rMY/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Lihat semua"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Kongsi dengan %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Kongsi dengan"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-my-rMM/strings.xml b/current/support/v7/appcompat/res/values-my-rMM/strings.xml
index 6313bcb..936ac99 100644
--- a/current/support/v7/appcompat/res/values-my-rMM/strings.xml
+++ b/current/support/v7/appcompat/res/values-my-rMM/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"အားလုံးကို ကြည့်ရန်"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s ကို မျှဝေပါရန်"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"မျှဝေဖို့ ရွေးပါ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"၉၉၉+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-nb/strings.xml b/current/support/v7/appcompat/res/values-nb/strings.xml
index 6e50a58..483f707 100644
--- a/current/support/v7/appcompat/res/values-nb/strings.xml
+++ b/current/support/v7/appcompat/res/values-nb/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Se alle"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Del med %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Del med"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ne-rNP/strings.xml b/current/support/v7/appcompat/res/values-ne-rNP/strings.xml
index 5b804d8..4a08778 100644
--- a/current/support/v7/appcompat/res/values-ne-rNP/strings.xml
+++ b/current/support/v7/appcompat/res/values-ne-rNP/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"सबै हेर्नुहोस्"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s सँग साझेदारी गर्नुहोस्"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"साझेदारी गर्नुहोस्..."</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"९९९+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-nl/strings.xml b/current/support/v7/appcompat/res/values-nl/strings.xml
index 61546df..38a7607 100644
--- a/current/support/v7/appcompat/res/values-nl/strings.xml
+++ b/current/support/v7/appcompat/res/values-nl/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Alles weergeven"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Delen met %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Delen met"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-pl/strings.xml b/current/support/v7/appcompat/res/values-pl/strings.xml
index 9d99e92..72fa439 100644
--- a/current/support/v7/appcompat/res/values-pl/strings.xml
+++ b/current/support/v7/appcompat/res/values-pl/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Zobacz wszystkie"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Udostępnij dla %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Udostępnij dla"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-pt-rPT/strings.xml b/current/support/v7/appcompat/res/values-pt-rPT/strings.xml
index e905530..d76c5c8 100644
--- a/current/support/v7/appcompat/res/values-pt-rPT/strings.xml
+++ b/current/support/v7/appcompat/res/values-pt-rPT/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver tudo"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Partilhar com %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Partilhar com"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"+999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-pt/strings.xml b/current/support/v7/appcompat/res/values-pt/strings.xml
index b6c94e9..dfcfce8 100644
--- a/current/support/v7/appcompat/res/values-pt/strings.xml
+++ b/current/support/v7/appcompat/res/values-pt/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Ver tudo"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Compartilhar com %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Compartilhar com"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ro/strings.xml b/current/support/v7/appcompat/res/values-ro/strings.xml
index a69eacc..55538ee 100644
--- a/current/support/v7/appcompat/res/values-ro/strings.xml
+++ b/current/support/v7/appcompat/res/values-ro/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Afișați-le pe toate"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Trimiteți la %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Trimiteți la"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"˃999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ru/strings.xml b/current/support/v7/appcompat/res/values-ru/strings.xml
index 4879b5d..03a2c8f 100644
--- a/current/support/v7/appcompat/res/values-ru/strings.xml
+++ b/current/support/v7/appcompat/res/values-ru/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Показать все"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Открыть доступ пользователю %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Открыть доступ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-si-rLK/strings.xml b/current/support/v7/appcompat/res/values-si-rLK/strings.xml
index 252448f..a03b5bd 100644
--- a/current/support/v7/appcompat/res/values-si-rLK/strings.xml
+++ b/current/support/v7/appcompat/res/values-si-rLK/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"සියල්ල බලන්න"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s සමඟ බෙදාගන්න"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"සමඟ බෙදාගන්න"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-sk/strings.xml b/current/support/v7/appcompat/res/values-sk/strings.xml
index 501e065..f7f0b81 100644
--- a/current/support/v7/appcompat/res/values-sk/strings.xml
+++ b/current/support/v7/appcompat/res/values-sk/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Zobraziť všetko"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Zdieľať pomocou %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Zdieľať pomocou"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-sl/strings.xml b/current/support/v7/appcompat/res/values-sl/strings.xml
index da49123..7d5f0bf 100644
--- a/current/support/v7/appcompat/res/values-sl/strings.xml
+++ b/current/support/v7/appcompat/res/values-sl/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Pokaži vse"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Deljenje z:"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Deljenje z"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-sr/strings.xml b/current/support/v7/appcompat/res/values-sr/strings.xml
index 9e2a9e8..e147d75 100644
--- a/current/support/v7/appcompat/res/values-sr/strings.xml
+++ b/current/support/v7/appcompat/res/values-sr/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Прикажи све"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Дели са апликацијом %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Дели са"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-sv/strings.xml b/current/support/v7/appcompat/res/values-sv/strings.xml
index 905e3ea..feebdb2 100644
--- a/current/support/v7/appcompat/res/values-sv/strings.xml
+++ b/current/support/v7/appcompat/res/values-sv/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Visa alla"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Dela med %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Dela med"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"&gt;999"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-sw/strings.xml b/current/support/v7/appcompat/res/values-sw/strings.xml
index 7287c0d..25c4039 100644
--- a/current/support/v7/appcompat/res/values-sw/strings.xml
+++ b/current/support/v7/appcompat/res/values-sw/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Angalia zote"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Shiriki na %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Shiriki na:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ta-rIN/strings.xml b/current/support/v7/appcompat/res/values-ta-rIN/strings.xml
index ab728a6..099526b 100644
--- a/current/support/v7/appcompat/res/values-ta-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-ta-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"எல்லாம் காட்டு"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s உடன் பகிர்"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"இதனுடன் பகிர்"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-te-rIN/strings.xml b/current/support/v7/appcompat/res/values-te-rIN/strings.xml
index 901859b..8ea231a 100644
--- a/current/support/v7/appcompat/res/values-te-rIN/strings.xml
+++ b/current/support/v7/appcompat/res/values-te-rIN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"అన్నీ చూడండి"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%sతో భాగస్వామ్యం చేయి"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"వీరితో భాగస్వామ్యం చేయి"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-th/strings.xml b/current/support/v7/appcompat/res/values-th/strings.xml
index e962aa5..cc5ab0a 100644
--- a/current/support/v7/appcompat/res/values-th/strings.xml
+++ b/current/support/v7/appcompat/res/values-th/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"ดูทั้งหมด"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"แชร์กับ %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"แชร์กับ"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-tl/strings.xml b/current/support/v7/appcompat/res/values-tl/strings.xml
index f41b15f..aa7169f 100644
--- a/current/support/v7/appcompat/res/values-tl/strings.xml
+++ b/current/support/v7/appcompat/res/values-tl/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Tingnan lahat"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Ibahagi sa/kay %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Ibahagi sa/kay"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-tr/strings.xml b/current/support/v7/appcompat/res/values-tr/strings.xml
index 9cde4a2..0d592fc 100644
--- a/current/support/v7/appcompat/res/values-tr/strings.xml
+++ b/current/support/v7/appcompat/res/values-tr/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Tümünü göster"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"%s ile paylaş"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Şununla paylaş"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-uk/strings.xml b/current/support/v7/appcompat/res/values-uk/strings.xml
index 0a5c31c..ff08b47 100644
--- a/current/support/v7/appcompat/res/values-uk/strings.xml
+++ b/current/support/v7/appcompat/res/values-uk/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Переглянути всі"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Надіслати через %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Надіслати через"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-ur-rPK/strings.xml b/current/support/v7/appcompat/res/values-ur-rPK/strings.xml
index e6f6260..5196476 100644
--- a/current/support/v7/appcompat/res/values-ur-rPK/strings.xml
+++ b/current/support/v7/appcompat/res/values-ur-rPK/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"سبھی دیکھیں"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"‏%s کے ساتھ اشتراک کریں"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"اشتراک کریں مع"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"‎999+‎"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-uz-rUZ/strings.xml b/current/support/v7/appcompat/res/values-uz-rUZ/strings.xml
index 241b3b1..fa884f7 100644
--- a/current/support/v7/appcompat/res/values-uz-rUZ/strings.xml
+++ b/current/support/v7/appcompat/res/values-uz-rUZ/strings.xml
@@ -35,4 +35,5 @@
     <!-- no translation found for abc_shareactionprovider_share_with_application (7165123711973476752) -->
     <skip />
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Bo‘lishish:"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-v14/styles.xml b/current/support/v7/appcompat/res/values-v14/styles.xml
new file mode 100644
index 0000000..f54796d
--- /dev/null
+++ b/current/support/v7/appcompat/res/values-v14/styles.xml
@@ -0,0 +1,33 @@
+<!--
+  ~ Copyright (C) 2015 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License
+  -->
+
+<resources>
+
+    <!-- Use platform styles -->
+    <style name="TextAppearance.StatusBar.EventContent"
+        parent="@android:style/TextAppearance.StatusBar.EventContent"/>
+
+    <style name="TextAppearance.StatusBar.EventContent.Title"
+        parent="@android:style/TextAppearance.StatusBar.EventContent.Title"/>
+
+    <!-- Use own styles for which platform styles are not public -->
+    <style name="TextAppearance.StatusBar.EventContent.Line2">
+        <item name="android:textSize">@dimen/notification_subtext_size</item>
+    </style>
+    <style name="TextAppearance.StatusBar.EventContent.Info"/>
+    <style name="TextAppearance.StatusBar.EventContent.Time"/>
+
+</resources>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/values-vi/strings.xml b/current/support/v7/appcompat/res/values-vi/strings.xml
index 9cf34c2..8190bc0 100644
--- a/current/support/v7/appcompat/res/values-vi/strings.xml
+++ b/current/support/v7/appcompat/res/values-vi/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Xem tất cả"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Chia sẻ với %s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Chia sẻ với"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-zh-rCN/strings.xml b/current/support/v7/appcompat/res/values-zh-rCN/strings.xml
index a0b492a..b0fbc2f 100644
--- a/current/support/v7/appcompat/res/values-zh-rCN/strings.xml
+++ b/current/support/v7/appcompat/res/values-zh-rCN/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"查看全部"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"通过%s分享"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"分享方式"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-zh-rHK/strings.xml b/current/support/v7/appcompat/res/values-zh-rHK/strings.xml
index 2e37307..2c46334 100644
--- a/current/support/v7/appcompat/res/values-zh-rHK/strings.xml
+++ b/current/support/v7/appcompat/res/values-zh-rHK/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"顯示全部"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"與「%s」分享"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"分享對象"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999 +"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-zh-rTW/strings.xml b/current/support/v7/appcompat/res/values-zh-rTW/strings.xml
index 41a9401..bfabf5a 100644
--- a/current/support/v7/appcompat/res/values-zh-rTW/strings.xml
+++ b/current/support/v7/appcompat/res/values-zh-rTW/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"查看全部"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"與「%s」分享"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"選擇分享對象"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values-zu/strings.xml b/current/support/v7/appcompat/res/values-zu/strings.xml
index 48d586b..edc265d 100644
--- a/current/support/v7/appcompat/res/values-zu/strings.xml
+++ b/current/support/v7/appcompat/res/values-zu/strings.xml
@@ -33,4 +33,5 @@
     <string name="abc_activity_chooser_view_see_all" msgid="7468859129482906941">"Buka konke"</string>
     <string name="abc_shareactionprovider_share_with_application" msgid="7165123711973476752">"Yabelana no-%s"</string>
     <string name="abc_shareactionprovider_share_with" msgid="3421042268587513524">"Yabelana no-"</string>
+    <string name="status_bar_notification_info_overflow" msgid="2869576371154716097">"999+"</string>
 </resources>
diff --git a/current/support/v7/appcompat/res/values/colors.xml b/current/support/v7/appcompat/res/values/colors.xml
index 3214201..0ce01d2 100644
--- a/current/support/v7/appcompat/res/values/colors.xml
+++ b/current/support/v7/appcompat/res/values/colors.xml
@@ -19,4 +19,6 @@
     <color name="abc_search_url_text_pressed">@android:color/black</color>
 
     <color name="abc_input_method_navigation_guard">@android:color/black</color>
+
+    <drawable name="notification_template_icon_bg">#3333B5E5</drawable>
 </resources>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/values/config.xml b/current/support/v7/appcompat/res/values/config.xml
index be6a7a1..e0c521b 100644
--- a/current/support/v7/appcompat/res/values/config.xml
+++ b/current/support/v7/appcompat/res/values/config.xml
@@ -38,4 +38,11 @@
 
     <bool name="abc_config_closeDialogWhenTouchOutside">true</bool>
 
+    <!-- Maximum numerical value that will be shown in a status bar
+         notification icon or in the notification itself. Will be replaced
+         with @string/status_bar_notification_info_overflow when shown in the
+         UI. -->
+    <integer name="status_bar_notification_info_maxnum">999</integer>
+
+    <integer name="cancel_button_image_alpha">127</integer>
 </resources>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/values/dimens.xml b/current/support/v7/appcompat/res/values/dimens.xml
index b8fa76c..06f1a06 100644
--- a/current/support/v7/appcompat/res/values/dimens.xml
+++ b/current/support/v7/appcompat/res/values/dimens.xml
@@ -97,4 +97,13 @@
          be either a fraction or a dimension. -->
     <item type="dimen" name="abc_dialog_min_width_minor">95%</item>
 
+    <!-- The width of the big icons in notifications. -->
+    <dimen name="notification_large_icon_width">64dp</dimen>
+
+    <!-- The width of the big icons in notifications. -->
+    <dimen name="notification_large_icon_height">64dp</dimen>
+
+    <!-- Size of smaller notification text (see TextAppearance.StatusBar.EventContent.Line2, Info,
+         Time) -->
+    <dimen name="notification_subtext_size">12dp</dimen>
 </resources>
diff --git a/current/support/v7/appcompat/res/values/strings.xml b/current/support/v7/appcompat/res/values/strings.xml
index 87cfd29..a04b396 100644
--- a/current/support/v7/appcompat/res/values/strings.xml
+++ b/current/support/v7/appcompat/res/values/strings.xml
@@ -62,4 +62,10 @@
     <!-- Description of the choose target button in a ShareActionProvider (share UI). [CHAR LIMIT=NONE] -->
     <string name="abc_shareactionprovider_share_with">Share with</string>
 
+    <!-- Text to use when the number in a notification info is too large
+         (greater than status_bar_notification_info_maxnum, defined in
+         values/config.xml) and must be truncated. May need to be localized
+         for most appropriate textual indicator of "more than X".
+         [CHAR LIMIT=4] -->
+    <string name="status_bar_notification_info_overflow">999+</string>
 </resources>
\ No newline at end of file
diff --git a/current/support/v7/appcompat/res/values/styles.xml b/current/support/v7/appcompat/res/values/styles.xml
index 1f30314..b38c6ad 100644
--- a/current/support/v7/appcompat/res/values/styles.xml
+++ b/current/support/v7/appcompat/res/values/styles.xml
@@ -321,4 +321,11 @@
     <style name="Widget.AppCompat.Light.AutoCompleteTextView" parent="Widget.AppCompat.AutoCompleteTextView" />
     <style name="Widget.AppCompat.Light.ActivityChooserView" parent="Widget.AppCompat.ActivityChooserView" />
 
+    <!-- These styles didn't exist on v7. Since we only use the media template in later versions
+         (ICS+), just define it here and use the correct references in values/v14 -->
+    <style name="TextAppearance.StatusBar.EventContent" parent=""/>
+    <style name="TextAppearance.StatusBar.EventContent.Title" parent=""/>
+    <style name="TextAppearance.StatusBar.EventContent.Line2" parent=""/>
+    <style name="TextAppearance.StatusBar.EventContent.Info" parent=""/>
+    <style name="TextAppearance.StatusBar.EventContent.Time" parent=""/>
 </resources>
diff --git a/current/support/v7/cardview/libs/android-support-v7-cardview.jar b/current/support/v7/cardview/libs/android-support-v7-cardview.jar
index f1b00b0..9628d2f 100644
--- a/current/support/v7/cardview/libs/android-support-v7-cardview.jar
+++ b/current/support/v7/cardview/libs/android-support-v7-cardview.jar
Binary files differ
diff --git a/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar b/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
index 273adfd..fa686f1 100644
--- a/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
+++ b/current/support/v7/gridlayout/libs/android-support-v7-gridlayout.jar
Binary files differ
diff --git a/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar b/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
index 1c13f2f..0f8a812 100644
--- a/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
+++ b/current/support/v7/mediarouter/libs/android-support-v7-mediarouter.jar
Binary files differ
diff --git a/current/support/v7/palette/libs/android-support-v7-palette.jar b/current/support/v7/palette/libs/android-support-v7-palette.jar
index 6659020..8d1c505 100644
--- a/current/support/v7/palette/libs/android-support-v7-palette.jar
+++ b/current/support/v7/palette/libs/android-support-v7-palette.jar
Binary files differ
diff --git a/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar b/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
index f27494a..b3f748e 100644
--- a/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
+++ b/current/support/v7/recyclerview/libs/android-support-v7-recyclerview.jar
Binary files differ
diff --git a/current/uiautomator.jar b/current/uiautomator.jar
index c4e4425..92ab095 100644
--- a/current/uiautomator.jar
+++ b/current/uiautomator.jar
Binary files differ
diff --git a/system_current/android.jar b/system_current/android.jar
index cfa930e..6382eeb 100644
--- a/system_current/android.jar
+++ b/system_current/android.jar
Binary files differ
