diff --git a/res-common/values/donottranslate_config.xml b/res-common/values/donottranslate_config.xml
index 9d9513b..e652590 100644
--- a/res-common/values/donottranslate_config.xml
+++ b/res-common/values/donottranslate_config.xml
@@ -33,6 +33,15 @@
     <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
     <bool name="config_editor_field_order_primary">true</bool>
 
+    <!-- If true, an option is shown in Display Options UI to choose a default account -->
+    <bool name="config_default_account_user_changeable">true</bool>
+
+    <!-- Contacts preferences key for contact editor default account -->
+    <string name="contact_editor_default_account_key">ContactEditorUtils_default_account</string>
+
+    <!-- Contacts preferences key for contact editor anything saved -->
+    <string name="contact_editor_anything_saved_key">ContactEditorUtils_anything_saved</string>
+
     <!-- The type of VCard for export. If you want to let the app emit vCard which is
     specific to some vendor (like DoCoMo), specify this type (e.g. "docomo") -->
     <string name="config_export_vcard_type" translatable="false">default</string>
diff --git a/res-common/values/strings.xml b/res-common/values/strings.xml
index e3fc643..c0fa03e 100644
--- a/res-common/values/strings.xml
+++ b/res-common/values/strings.xml
@@ -656,6 +656,9 @@
     <!-- An allowable value for the "view names as" contact display option  -->
     <string name="display_options_view_family_name_first">Last name first</string>
 
+    <!--Label of the "default account" setting option to set default editor account-->
+    <string name="default_editor_account">Default account</string>
+
     <!-- Action that shares visible contacts -->
     <string name="share_visible_contacts">Share visible contacts</string>
 
diff --git a/res-common/xml/preference_display_options.xml b/res-common/xml/preference_display_options.xml
index f327fac..6b46ec8 100644
--- a/res-common/xml/preference_display_options.xml
+++ b/res-common/xml/preference_display_options.xml
@@ -24,4 +24,9 @@
         android:key="displayOrder"
         android:title="@string/display_options_view_names_as"
         android:dialogTitle="@string/display_options_view_names_as" />
+
+    <com.android.contacts.common.preference.DefaultAccountPreference
+        android:key="accounts"
+        android:title="@string/default_editor_account"
+        android:dialogTitle="@string/default_editor_account" />
 </PreferenceScreen>
