diff --git a/res/layout/conference_call_user_list.xml b/res/layout/conference_call_user_list.xml
index 018a726..4a07c62 100644
--- a/res/layout/conference_call_user_list.xml
+++ b/res/layout/conference_call_user_list.xml
@@ -30,7 +30,7 @@
         android:layout_height="wrap_content"
         android:layout_marginTop="35dp"
         android:layout_marginBottom="35dp"
-        android:layout_marginLeft="135dp"
+        android:layout_marginLeft="170dp"
         app:layout_constraintBottom_toTopOf="@+id/recycler_view"
         app:layout_constraintTop_toTopOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
diff --git a/res/layout/onhold_user_profile.xml b/res/layout/onhold_user_profile.xml
index 1b04877..a557658 100644
--- a/res/layout/onhold_user_profile.xml
+++ b/res/layout/onhold_user_profile.xml
@@ -47,29 +47,41 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:theme="@style/Theme.Dialer.BidiText"
-            android:layout_marginEnd="@dimen/onhold_profile_status_margin"
             android:textAppearance="?android:attr/textAppearanceLarge"
             android:singleLine="true"
             app:layout_constraintTop_toTopOf="parent"
             app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintStart_toStartOf="@id/guideline"
+            app:layout_constraintEnd_toStartOf="@+id/title_separator"/>
+
+        <TextView
+            android:id="@id/title_separator"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginStart="@dimen/onhold_profile_status_margin"
+            android:layout_marginEnd="@dimen/onhold_profile_status_margin"
+            android:textAppearance="?android:attr/textAppearanceLarge"
+            android:singleLine="true"
+            android:text="@string/onhold_call_separator"
+            app:layout_constraintTop_toTopOf="parent"
+            app:layout_constraintBottom_toBottomOf="parent"
+            app:layout_constraintStart_toEndOf="@id/title"
             app:layout_constraintEnd_toStartOf="@+id/time"/>
 
         <Chronometer
             android:id="@id/time"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_marginStart="@dimen/onhold_profile_status_margin"
             android:textAppearance="?android:attr/textAppearanceLarge"
             android:textColor="@color/onhold_time_color"
             android:singleLine="true"
             app:layout_constraintTop_toTopOf="parent"
             app:layout_constraintBottom_toBottomOf="parent"
-            app:layout_constraintStart_toEndOf="@id/title"
-            app:layout_constraintEnd_toStartOf="@+id/separator"/>
+            app:layout_constraintStart_toEndOf="@id/title_separator"
+            app:layout_constraintEnd_toStartOf="@+id/time_separator"/>
 
         <TextView
-            android:id="@id/separator"
+            android:id="@id/time_separator"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginStart="@dimen/onhold_profile_status_margin"
@@ -92,7 +104,7 @@
             android:textColor="@color/onhold_label_color"
             app:layout_constraintTop_toTopOf="parent"
             app:layout_constraintBottom_toBottomOf="parent"
-            app:layout_constraintStart_toEndOf="@id/separator"
+            app:layout_constraintStart_toEndOf="@id/time_separator"
             app:layout_constraintEnd_toStartOf="@+id/swap_call"/>
 
         <TextView
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 1349709..b3da20b 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -59,14 +59,14 @@
     <dimen name="in_call_state_margin_top">@dimen/car_ui_padding_2</dimen>
     <dimen name="in_call_margin_between_avatar_and_text">48dp</dimen>
     <dimen name="in_call_user_profile_margin">@dimen/car_ui_margin</dimen>
-    <dimen name="in_call_user_profile_list_margin">20dp</dimen>
+    <dimen name="in_call_user_profile_list_margin">60dp</dimen>
     <dimen name="onhold_user_info_height">90dp</dimen>
     <dimen name="onhold_profile_margin_x">@dimen/list_item_padding</dimen>
     <dimen name="onhold_profile_margin_y">@dimen/car_ui_padding_3</dimen>
     <dimen name="onhold_profile_corner_radius">8dp</dimen>
     <dimen name="onhold_profile_avatar_margin">@dimen/car_keyline_1</dimen>
     <dimen name="onhold_profile_guideline">@dimen/list_item_guideline</dimen>
-    <dimen name="onhold_profile_status_margin">6dp</dimen>
+    <dimen name="onhold_profile_status_margin">12dp</dimen>
     <dimen name="user_profile_list_item_height">150dp</dimen>
 
     <!-- Ringing call dimensions -->
diff --git a/src/com/android/car/dialer/ui/activecall/ConferenceProfileViewHolder.java b/src/com/android/car/dialer/ui/activecall/ConferenceProfileViewHolder.java
index 7d020aa..9dc5f88 100644
--- a/src/com/android/car/dialer/ui/activecall/ConferenceProfileViewHolder.java
+++ b/src/com/android/car/dialer/ui/activecall/ConferenceProfileViewHolder.java
@@ -79,7 +79,7 @@
                             && !phoneNumberLabel.equals(info.getDisplayName())) {
                         mNumber.setText(phoneNumberLabel);
                     } else {
-                        mNumber.setText(null);
+                        mNumber.setText(mContext.getString(R.string.unknown));
                     }
 
                     LetterTileDrawable letterTile = TelecomUtils.createLetterTile(
