diff --git a/InCallUI/res/layout/primary_call_info.xml b/InCallUI/res/layout/primary_call_info.xml
index 3763e24..c680ed6 100644
--- a/InCallUI/res/layout/primary_call_info.xml
+++ b/InCallUI/res/layout/primary_call_info.xml
@@ -60,7 +60,9 @@
             android:scaleType="center"
             android:visibility="gone" />
 
-        <TextView android:id="@+id/callStateLabel"
+        <com.android.phone.common.widget.ResizingTextTextView
+            xmlns:ex="http://schemas.android.com/apk/res-auto"
+            android:id="@+id/callStateLabel"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:textAlignment="viewStart"
@@ -70,13 +72,15 @@
             android:alpha="0.7"
             android:singleLine="true"
             android:gravity="start"
-            android:ellipsize="end" />
+            android:ellipsize="end"
+            ex:resizing_text_min_size="@dimen/call_status_text_min_size" />
 
     </LinearLayout>
 
     <!-- Name (or the phone number, if we don't have a name to display). -->
-    <com.android.phone.common.widget.ResizingTextTextView android:id="@+id/name"
+    <com.android.phone.common.widget.ResizingTextTextView
         xmlns:ex="http://schemas.android.com/apk/res-auto"
+        android:id="@+id/name"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:layout_marginTop="-5dp"
diff --git a/InCallUI/res/values-sw360dp/dimens.xml b/InCallUI/res/values-sw360dp/dimens.xml
index 58c81bb..d6ee5b4 100644
--- a/InCallUI/res/values-sw360dp/dimens.xml
+++ b/InCallUI/res/values-sw360dp/dimens.xml
@@ -23,6 +23,7 @@
     <dimen name="call_banner_height">122dp</dimen>
     <!-- Text size for the name in the call info. -->
     <dimen name="call_status_text_size">22sp</dimen>
+    <dimen name="call_status_text_min_size">18sp</dimen>
     <dimen name="call_name_text_size">45dp</dimen>
     <dimen name="call_name_text_min_size">34sp</dimen>
     <dimen name="call_label_text_size">18sp</dimen>
@@ -34,4 +35,4 @@
     <dimen name="dialpad_digits_adjustable_text_size">@dimen/dialpad_digits_text_size</dimen>
     <dimen name="dialpad_digits_adjustable_height">@dimen/dialpad_digits_height</dimen>
     <dimen name="dialpad_key_numbers_size">@dimen/dialpad_key_numbers_default_size</dimen>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/InCallUI/res/values/dimens.xml b/InCallUI/res/values/dimens.xml
index 0739234..6485377 100644
--- a/InCallUI/res/values/dimens.xml
+++ b/InCallUI/res/values/dimens.xml
@@ -44,8 +44,9 @@
 
     <!-- Text sizes for information in the call card.
          Note: These are the default sizes for small (<600dp height) devices: larger screen sizes
-         apply the values in values-h600dp/dimens.xml. -->
+         apply the values in values-sw360dp/dimens.xml. -->
     <dimen name="call_status_text_size">16sp</dimen>
+    <dimen name="call_status_text_min_size">12sp</dimen>
     <dimen name="call_name_text_size">34dp</dimen>
     <dimen name="call_name_text_min_size">28sp</dimen>
     <dimen name="call_label_text_size">16sp</dimen>
diff --git a/InCallUI/res/values/strings.xml b/InCallUI/res/values/strings.xml
index b967306..cadef73 100644
--- a/InCallUI/res/values/strings.xml
+++ b/InCallUI/res/values/strings.xml
@@ -87,21 +87,21 @@
     <string name="voicemail_settings_number_label">Voicemail number</string>
 
     <!-- Card titles -->
-    <!-- In-call screen: status label for a call in the "dialing" state -->
+    <!-- In-call screen: status label for a call in the "dialing" state [CHAR LIMIT=25] -->
     <string name="card_title_dialing">Dialing</string>
-    <!-- In-call screen: status label for a re-dialing call -->
+    <!-- In-call screen: status label for a re-dialing call [CHAR LIMIT=25] -->
     <string name="card_title_redialing">Redialing</string>
-    <!-- In-call screen: status label for a conference call -->
+    <!-- In-call screen: status label for a conference call [CHAR LIMIT=25] -->
     <string name="card_title_conf_call">Conference call</string>
-    <!-- In-call screen: status label for an incoming call -->
+    <!-- In-call screen: status label for an incoming call [CHAR LIMIT=25] -->
     <string name="card_title_incoming_call">Incoming call</string>
-    <!-- In-call screen: status label displayed briefly after a call ends -->
+    <!-- In-call screen: status label displayed briefly after a call ends [CHAR LIMIT=25] -->
     <string name="card_title_call_ended">Call ended</string>
-    <!-- In-call screen: status label for call that's on hold -->
+    <!-- In-call screen: status label for call that's on hold [CHAR LIMIT=25] -->
     <string name="card_title_on_hold">On hold</string>
-    <!-- In-call screen: status label for a call that's in the process of hanging up -->
+    <!-- In-call screen: status label for a call that's in the process of hanging up [CHAR LIMIT=25] -->
     <string name="card_title_hanging_up">Hanging up</string>
-    <!-- In-call screen: status label for a call that's in CDMA flash mode -->
+    <!-- In-call screen: status label for a call that's in CDMA flash mode [CHAR LIMIT=25] -->
     <string name="card_title_in_call">In call</string>
     <!-- In-call screen: special status label that shows your own phone
          number during emergency callback mode (ECM) [CHAR LIMIT=30] -->
