diff --git a/res-common/values/donottranslate_config.xml b/res-common/values/donottranslate_config.xml
index 1e0ee40..9d9513b 100644
--- a/res-common/values/donottranslate_config.xml
+++ b/res-common/values/donottranslate_config.xml
@@ -15,18 +15,8 @@
   -->
 
 <resources>
-    <!-- Flag indicating whether Contacts app is allowed to import contacts from SDCard -->
-    <bool name="config_allow_import_from_sdcard">true</bool>
-    <!-- If true, all vcard files are imported from SDCard without asking a user.
-    If not, dialog shows to let the user to select whether all vcard files are imported or not.
-    If the user selects "not", then the application ask the user to select a file.-->
-    <bool name="config_import_all_vcard_from_sdcard_automatically">false</bool>
-    <!-- If true, vcard importer shows a dialog which asks the user whether the user wants
-    to import all vcard files in SDCard or select one vcard file. If false, the dialog is
-    skipped and the importer asks the user to choose one vcard file.
-    If config_import_all_vcard_from_sdcard_automatically is set true, this configuration
-    is ignored. -->
-    <bool name="config_allow_users_select_all_vcard_import">true</bool>
+    <!-- Flag indicating whether Contacts app is allowed to import contacts -->
+    <bool name="config_allow_import_from_vcf_file">true</bool>
 
     <!-- If true, an option is shown in Display Options UI to choose a sort order -->
     <bool name="config_sort_order_user_changeable">true</bool>
diff --git a/res-common/values/ids.xml b/res-common/values/ids.xml
index 41cee45..4ba65e1 100644
--- a/res-common/values/ids.xml
+++ b/res-common/values/ids.xml
@@ -16,14 +16,7 @@
 
 <resources>
     <!-- For vcard.ImportVCardActivity -->
-    <item type="id" name="dialog_searching_vcard"/>
-    <item type="id" name="dialog_sdcard_not_found"/>
-    <item type="id" name="dialog_vcard_not_found"/>
-    <item type="id" name="dialog_select_import_type"/>
-    <item type="id" name="dialog_select_one_vcard"/>
-    <item type="id" name="dialog_select_multiple_vcard"/>
     <item type="id" name="dialog_cache_vcard"/>
-    <item type="id" name="dialog_io_exception"/>
     <item type="id" name="dialog_error_with_message"/>
 
     <!-- For vcard.CancelActivity -->
diff --git a/res-common/values/strings.xml b/res-common/values/strings.xml
index ddeee23..c3725a3 100644
--- a/res-common/values/strings.xml
+++ b/res-common/values/strings.xml
@@ -428,8 +428,8 @@
     <!-- Action string for selecting a SIM subscription for importing contacts, without a phone number -->
     <string name="import_from_sim_summary_no_number">Import from SIM <xliff:g id="sim_name">%1$s</xliff:g></string>
 
-    <!-- Action string for selecting (USB) storage for importing contacts [CHAR LIMIT=30] -->
-    <string name="import_from_sdcard" product="default">Import from storage</string>
+    <!-- Action string for selecting a .vcf file to import contacts from [CHAR LIMIT=30] -->
+    <string name="import_from_vcf_file" product="default">Import from .vcf file</string>
 
     <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard import.
          The argument is file name for the vCard import the user wants to cancel.
@@ -545,11 +545,6 @@
     <!-- Dialog message shown when exporting Contact data failed. [CHAR LIMIT=NONE] -->
     <string name="exporting_contact_failed_message">The contact data wasn\'t exported.\nReason: \"<xliff:g id="fail_reason">%s</xliff:g>\"</string>
 
-    <!-- Dialog message shown when (USB) storage does not exist [CHAR LIMIT=30] -->
-    <string name="no_sdcard_message" product="nosdcard">No storage was found.</string>
-    <!-- Dialog message shown when SDcard does not exist. [CHAR LIMIT=30] -->
-    <string name="no_sdcard_message" product="default">No SD card was found.</string>
-
     <!-- Description shown when importing vCard data.
          The argument is the name of a contact which is being read.
          [CHAR LIMIT=20] -->
@@ -620,29 +615,6 @@
     <!-- Dialog title shown when a user confirms whether he/she export Contact data. [CHAR LIMIT=32] -->
     <string name="confirm_export_title">Export contacts?</string>
 
-    <!-- Dialog title shown when a user is asked to select vCard file. [CHAR LIMIT=25] -->
-    <string name="select_vcard_title">Choose vCard file</string>
-
-    <!-- One of alternatives shown when the system allows a user to select how many vCard files
-         should be imported. This message shows only when the system is certain that there's more
-         than one vCard files available in the system. -->
-    <string name="import_one_vcard_string">Import one vCard file</string>
-
-    <!-- One of alternatives shown when the system allows a user to select how many vCard files
-         should be imported. This message shows only when the system is certain that there's more
-         than one vCard files available in the system. -->
-    <string name="import_multiple_vcard_string">Import multiple vCard files</string>
-
-    <!-- One of alternatives shown when the system allows a user to select how many vCard files
-         should be imported. This message shows only when the system is certain that there's more
-         than one vCard files available in the system. -->
-    <string name="import_all_vcard_string">Import all vCard files</string>
-
-    <!-- Dialog message shown when searching VCard data from (USB) storage [CHAR LIMIT=NONE] -->
-    <string name="searching_vcard_message" product="nosdcard">Searching for vCard data in storage\u2026</string>
-    <!-- Dialog message shown when searching VCard data from SD Card. [CHAR LIMIT=NONE] -->
-    <string name="searching_vcard_message" product="default">Searching for vCard data on SD card\u2026</string>
-
     <!-- The title shown when vCard importer is caching files to be imported into local temporary
          data storage.  [CHAR LIMIT=40] -->
     <string name="caching_vcard_title">Caching</string>
@@ -662,7 +634,7 @@
     <string name="progress_notifier_message">Importing <xliff:g id="current_number">%s</xliff:g>/<xliff:g id="total_number">%s</xliff:g>: <xliff:g id="name" example="Joe Due">%s</xliff:g></string>
 
     <!-- Action that exports all contacts to a user selected destination. [CHAR LIMIT=25] -->
-    <string name="export" product="default">Export</string>
+    <string name="export_to_vcf_file" product="default">Export to .vcf file</string>
 
     <!-- Contact preferences related strings -->
 
