diff --git a/res/color/option_border_color.xml b/res/color/option_border_color.xml
index b84891f..ea5f189 100644
--- a/res/color/option_border_color.xml
+++ b/res/color/option_border_color.xml
@@ -20,7 +20,8 @@
         android:color="?android:colorAccent" />
     <item
         android:state_activated="false"
-        android:color="@color/material_grey500" />
+        android:alpha="0.24"
+        android:color="?android:colorAccent" />
     <item
         android:color="@color/material_grey500"/>
-</selector>
\ No newline at end of file
+</selector>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 5487661..8cf3a1f 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -17,6 +17,7 @@
 -->
 <resources>
     <dimen name="bottom_navbar_height">56dp</dimen>
+    <dimen name="bottom_navbar_font_text_size">12sp</dimen>
 
     <dimen name="preview_indicator_width">16dp</dimen>
     <dimen name="preview_indicator_height">8dp</dimen>
@@ -43,6 +44,7 @@
     <dimen name="option_tile_padding_horizontal">10dp</dimen>
     <!-- Note, using dp instead of sp as this text is more like a "snapshot" of the font -->
     <dimen name="theme_option_font_text_size">10dp</dimen>
+    <dimen name="theme_option_title_font_text_size">12sp</dimen>
 
     <dimen name="option_tile_margin_horizontal">4dp</dimen>
     <dimen name="theme_option_label_margin">4dp</dimen>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 9cfda57..a4e79ba 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -35,11 +35,11 @@
         <item name="itemTextColor">@color/bottom_nav_item_color</item>
         <item name="itemTextAppearanceActive">@style/BottomNavTextAppearance</item>
         <item name="itemTextAppearanceInactive">@style/BottomNavTextAppearance</item>
-         <item name="android:background">?android:colorPrimary</item>
+        <item name="android:background">?android:colorPrimary</item>
     </style>
 
-    <style name="BottomNavTextAppearance" parent="@android:style/TextAppearance.DeviceDefault.Small">
-        <item name="android:textStyle">bold</item>
+    <style name="BottomNavTextAppearance" parent="@android:style/TextAppearance.DeviceDefault.Widget.ActionBar.Title">
+        <item name="android:textSize">@dimen/bottom_navbar_font_text_size</item>
     </style>
     <style name="RegularToolbarStyle" parent="@android:style/Widget.DeviceDefault.Light.ActionBar.Solid">
         <item name="android:elevation">0dp</item>
@@ -49,9 +49,10 @@
 
     <style name="ActionPrimaryButton" parent="android:Widget.DeviceDefault.Button.Colored"/>
 
-    <style name="OptionTitleTextAppearance" parent="@android:style/TextAppearance.DeviceDefault.Small">
+    <style name="OptionTitleTextAppearance" parent="@android:style/TextAppearance.DeviceDefault.Widget.ActionBar.Title">
         <item name="android:textColor">@color/option_title_color</item>
         <item name="android:textAlignment">center</item>
+        <item name="android:textSize">@dimen/theme_option_title_font_text_size</item>
     </style>
 
 
diff --git a/src/com/android/customization/picker/theme/ThemeFragment.java b/src/com/android/customization/picker/theme/ThemeFragment.java
index ea5d023..99deb83 100644
--- a/src/com/android/customization/picker/theme/ThemeFragment.java
+++ b/src/com/android/customization/picker/theme/ThemeFragment.java
@@ -285,7 +285,7 @@
             if (previewInfo.icons.size() >= mIconIds.length) {
                 addPage(new ThemePreviewPage(activity, R.string.preview_name_icon,
                         R.drawable.ic_wifi_24px, R.layout.preview_card_icon_content,
-                        previewInfo.colorAccentLight) {
+                        previewInfo.resolveAccentColor(res)) {
                     @Override
                     protected void bindBody(boolean forceRebind) {
                         for (int i = 0; i < mIconIds.length; i++) {
