contact backup & import

build.gradle

@@ -118,6 +118,7 @@ android {
 
     packagingOptions {
         exclude 'META-INF/LICENSE.txt'
+        exclude 'META-INF/LICENSE'
     }
 
     task checkstyle(type: Checkstyle) {
@@ -191,6 +192,7 @@ dependencies {
     compile 'com.jakewharton:butterknife:8.4.0'
     annotationProcessor 'com.jakewharton:butterknife-compiler:8.4.0'
     compile 'org.greenrobot:eventbus:3.0.0'
+    compile 'com.googlecode.ez-vcard:ez-vcard:0.10.2'
 
     compile 'org.parceler:parceler-api:1.1.6'
     annotationProcessor 'org.parceler:parceler:1.1.6'

src/main/AndroidManifest.xml

@@ -35,6 +35,9 @@
         See note in http://developer.android.com/intl/es/reference/android/Manifest.permission.html#GET_ACCOUNTS -->
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
 
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+
     <!-- USE_CREDENTIALS, MANAGE_ACCOUNTS and AUTHENTICATE_ACCOUNTS are needed for API < 23.
         In API >= 23 the do not exist anymore -->
     <uses-permission android:name="android.permission.USE_CREDENTIALS" />
@@ -80,6 +83,7 @@
         <activity android:name=".ui.activity.ActivitiesListActivity"/>
         <activity android:name=".ui.activity.FolderSyncActivity" />
         <activity android:name=".ui.activity.UploadFilesActivity" />
+        <activity android:name=".ui.activity.ContactsPreferenceActivity" />
         <activity android:name=".ui.activity.ReceiveExternalFilesActivity"
                   
                   android:taskAffinity=""

src/main/java/com/owncloud/android/services/ContactsBackupJob.java

@@ -0,0 +1,210 @@
+/**
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2017 Tobias Kaminsky
+ * Copyright (C) 2017 Nextcloud GmbH.
+ * <p>
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ * <p>
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * <p>
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.services;
+
+import android.accounts.Account;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.provider.ContactsContract;
+import android.support.annotation.NonNull;
+import android.text.format.DateFormat;
+
+import com.evernote.android.job.Job;
+import com.evernote.android.job.util.support.PersistableBundleCompat;
+import com.owncloud.android.MainApp;
+import com.owncloud.android.R;
+import com.owncloud.android.authentication.AccountUtils;
+import com.owncloud.android.datamodel.FileDataStorageManager;
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.db.PreferenceManager;
+import com.owncloud.android.files.services.FileUploader;
+import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.operations.UploadFileOperation;
+import com.owncloud.android.ui.activity.ContactsPreferenceActivity;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Vector;
+
+/**
+ * Job that backup contacts to /Contacts-Backup and deletes files older than x days
+ */
+
+public class ContactsBackupJob extends Job {
+    public static final String TAG = "ContactsBackupJob";
+    public static final String ACCOUNT = "account";
+    public static final String FORCE = "force";
+
+
+    @NonNull
+    @Override
+    protected Result onRunJob(Params params) {
+        final Context context = MainApp.getAppContext();
+        PersistableBundleCompat bundle = params.getExtras();
+
+        boolean force = bundle.getBoolean(FORCE, false);
+
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+        Long lastExecution = sharedPreferences.getLong(ContactsPreferenceActivity.PREFERENCE_CONTACTS_LAST_BACKUP, -1);
+
+        if (force || (lastExecution + 24 * 60 * 60 * 1000) < Calendar.getInstance().getTimeInMillis()) {
+            Log_OC.d(TAG, "start contacts backup job");
+
+            final Account account = AccountUtils.getOwnCloudAccountByName(context, bundle.getString(ACCOUNT, ""));
+            String backupFolder = getContext().getResources().getString(R.string.contacts_backup_folder) +
+                    OCFile.PATH_SEPARATOR;
+            Integer daysToExpire = getContext().getResources().getInteger(R.integer.contacts_backup_expire);
+
+            backupContact(account, backupFolder);
+
+            expireFiles(daysToExpire, backupFolder, account);
+
+            // store execution date
+            sharedPreferences.edit().putLong(ContactsPreferenceActivity.PREFERENCE_CONTACTS_LAST_BACKUP,
+                    Calendar.getInstance().getTimeInMillis()).apply();
+
+        } else {
+            Log_OC.d(TAG, "last execution less than 24h ago");
+        }
+
+        return Result.SUCCESS;
+    }
+
+    private void backupContact(Account account, String backupFolder) {
+        ArrayList<String> vCard = new ArrayList<>();
+        try {
+
+            Cursor cursor = getContext().getContentResolver().query(ContactsContract.Contacts.CONTENT_URI, null,
+                    null, null, null);
+
+            if (cursor != null && cursor.getCount() > 0) {
+                cursor.moveToFirst();
+                for (int i = 0; i < cursor.getCount(); i++) {
+
+                    vCard.add(getContactFromCursor(cursor));
+                    cursor.moveToNext();
+                }
+            }
+
+            String filename = DateFormat.format("yyyy-MM-dd_HH-mm-ss", Calendar.getInstance()).toString() + ".vcf";
+            Log_OC.d(TAG, "Storing: " + filename);
+            File file = new File(getContext().getCacheDir(), filename);
+
+            FileWriter fw = null;
+            try {
+                fw = new FileWriter(file);
+
+                for (String card : vCard) {
+                    fw.write(card);
+                }
+
+            } catch (IOException e) {
+                Log_OC.d(TAG, "Error ", e);
+            } finally {
+                if (fw != null) {
+                    try {
+                        fw.close();
+                    } catch (IOException e) {
+                        Log_OC.d(TAG, "Error closing file writer ", e);
+                    }
+                }
+            }
+
+            FileUploader.UploadRequester requester = new FileUploader.UploadRequester();
+            requester.uploadNewFile(
+                    getContext(),
+                    account,
+                    file.getAbsolutePath(),
+                    backupFolder + filename,
+                    FileUploader.LOCAL_BEHAVIOUR_MOVE,
+                    null,
+                    true,
+                    UploadFileOperation.CREATED_BY_USER
+            );
+
+        } catch (Exception e) {
+            Log_OC.d(TAG, e.getMessage());
+        }
+    }
+
+    private void expireFiles(Integer daysToExpire, String backupFolderString, Account account) {
+        // -1 disables expiration
+        if (daysToExpire > -1) {
+            FileDataStorageManager storageManager = new FileDataStorageManager(account, getContext().getContentResolver());
+            OCFile backupFolder = storageManager.getFileByPath(backupFolderString);
+            Calendar cal = Calendar.getInstance();
+            cal.add(Calendar.DAY_OF_YEAR, -daysToExpire);
+            Long timestampToExpire = cal.getTimeInMillis();
+
+            Log_OC.d(TAG, "expire: " + daysToExpire + " " + backupFolder.getFileName());
+
+            Vector<OCFile> backups = storageManager.getFolderContent(backupFolder, false);
+
+            for (OCFile backup : backups) {
+                if (timestampToExpire > backup.getModificationTimestamp()) {
+                    Log_OC.d(TAG, "delete " + backup.getRemotePath());
+
+                    // delete backups
+                    Intent service = new Intent(getContext(), OperationsService.class);
+                    service.setAction(OperationsService.ACTION_REMOVE);
+                    service.putExtra(OperationsService.EXTRA_ACCOUNT, account);
+                    service.putExtra(OperationsService.EXTRA_REMOTE_PATH, backup.getRemotePath());
+                    service.putExtra(OperationsService.EXTRA_REMOVE_ONLY_LOCAL, false);
+
+                    getContext().startService(service);
+                }
+            }
+        }
+    }
+
+    private String getContactFromCursor(Cursor cursor) {
+        String lookupKey = cursor.getString(cursor.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
+        Uri uri = Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_VCARD_URI, lookupKey);
+        ParcelFileDescriptor fd;
+
+        String vCard = "";
+        try {
+            fd = getContext().getContentResolver().openFileDescriptor(uri, "r");
+            FileInputStream fis;
+            if (fd != null) {
+                fis = new FileInputStream(fd.getFileDescriptor());
+                byte[] buf = new byte[fis.available()];
+                fis.read(buf);
+                vCard = new String(buf);
+            }
+
+            return vCard;
+
+        } catch (IOException e) {
+            Log_OC.d(TAG, e.getMessage());
+        }
+        return vCard;
+    }
+}

src/main/java/com/owncloud/android/services/ContactsImportJob.java

@@ -0,0 +1,77 @@
+/**
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2017 Tobias Kaminsky
+ * Copyright (C) 2017 Nextcloud GmbH.
+ * <p>
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ * <p>
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * <p>
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.services;
+
+import android.support.annotation.NonNull;
+
+import com.evernote.android.job.Job;
+import com.evernote.android.job.util.support.PersistableBundleCompat;
+import com.owncloud.android.lib.common.utils.Log_OC;
+
+import java.io.File;
+import java.util.ArrayList;
+
+import ezvcard.Ezvcard;
+import ezvcard.VCard;
+import third_parties.ezvcard_android.ContactOperations;
+
+/**
+ * Job to import contacts
+ */
+
+public class ContactsImportJob extends Job {
+    public static final String TAG = "ContactsImportJob";
+
+    public static final String ACCOUNT_TYPE = "account_type";
+    public static final String ACCOUNT_NAME = "account_name";
+    public static final String VCARD_FILE_PATH = "vcard_file_path";
+    public static final String CHECKED_ITEMS_ARRAY = "checked_items_array";
+
+    @NonNull
+    @Override
+    protected Result onRunJob(Params params) {
+        PersistableBundleCompat bundle = params.getExtras();
+
+        String vCardFilePath = bundle.getString(VCARD_FILE_PATH, "");
+        String accountName = bundle.getString(ACCOUNT_NAME, "");
+        String accountType = bundle.getString(ACCOUNT_TYPE, "");
+        int[] intArray = bundle.getIntArray(CHECKED_ITEMS_ARRAY);
+
+        File file = new File(vCardFilePath);
+        ArrayList<VCard> vCards = new ArrayList<>();
+
+        try {
+            ContactOperations operations = new ContactOperations(getContext(), accountName, accountType);
+            vCards.addAll(Ezvcard.parse(file).all());
+
+            for (int i = 0; i < intArray.length; i++ ){
+                if (intArray[i] == 1){
+                    operations.insertContact(vCards.get(i));
+                }
+            }
+        } catch (Exception e) {
+            Log_OC.e(TAG, e.getMessage());
+        }
+
+        return Result.SUCCESS;
+    }
+}

src/main/java/com/owncloud/android/services/NCJobCreator.java

@@ -4,17 +4,17 @@
  * @author Mario Danic
  * Copyright (C) 2017 Mario Danic
  * Copyright (C) 2017 Nextcloud GmbH
- *
+ * <p>
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Affero General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * at your option) any later version.
- *
+ * <p>
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Affero General Public License for more details.
- *
+ * <p>
  * You should have received a copy of the GNU Affero General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
@@ -33,6 +33,10 @@ public class NCJobCreator implements JobCreator {
         switch (tag) {
             case AutoUploadJob.TAG:
                 return new AutoUploadJob();
+            case ContactsBackupJob.TAG:
+                return new ContactsBackupJob();
+            case ContactsImportJob.TAG:
+                return new ContactsImportJob();
             default:
                 return null;
         }

src/main/java/com/owncloud/android/ui/activity/ContactListFragment.java

@@ -0,0 +1,353 @@
+/**
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2017 Tobias Kaminsky
+ * Copyright (C) 2017 Nextcloud GmbH.
+ * <p>
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ * <p>
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * <p>
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.ui.activity;
+
+import android.Manifest;
+import android.accounts.Account;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.database.Cursor;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.provider.ContactsContract;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.design.widget.Snackbar;
+import android.support.v7.app.AlertDialog;
+import android.util.SparseBooleanArray;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Button;
+import android.widget.CheckedTextView;
+import android.widget.ListView;
+import android.widget.QuickContactBadge;
+import android.widget.TextView;
+
+import com.evernote.android.job.JobRequest;
+import com.evernote.android.job.util.support.PersistableBundleCompat;
+import com.owncloud.android.R;
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.files.services.FileDownloader;
+import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.services.ContactsImportJob;
+import com.owncloud.android.ui.fragment.FileFragment;
+import com.owncloud.android.utils.PermissionUtil;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import ezvcard.Ezvcard;
+import ezvcard.VCard;
+import ezvcard.property.StructuredName;
+
+/**
+ * This fragment shows all contacts from a file and allows to import them.
+ */
+
+public class ContactListFragment extends FileFragment {
+    public static final String TAG = ContactListFragment.class.getSimpleName();
+
+    public static final String FILE_NAME = "FILE_NAME";
+    public static final String ACCOUNT = "ACCOUNT";
+
+    private ListView listView;
+    private ArrayList<VCard> vCards;
+
+    public static ContactListFragment newInstance(OCFile file, Account account) {
+        ContactListFragment frag = new ContactListFragment();
+        Bundle arguments = new Bundle();
+        arguments.putParcelable(FILE_NAME, file);
+        arguments.putParcelable(ACCOUNT, account);
+        frag.setArguments(arguments);
+
+        return frag;
+    }
+
+    public ContactListFragment() {
+        super();
+    }
+
+    @Override
+    public View onCreateView(final LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+
+        View view = inflater.inflate(R.layout.contactlist_fragment, null);
+
+        vCards = new ArrayList<>();
+
+        try {
+            OCFile ocFile = getArguments().getParcelable(FILE_NAME);
+            setFile(ocFile);
+            Account account = getArguments().getParcelable(ACCOUNT);
+
+            if (!ocFile.isDown()) {
+                Intent i = new Intent(getContext(), FileDownloader.class);
+                i.putExtra(FileDownloader.EXTRA_ACCOUNT, account);
+                i.putExtra(FileDownloader.EXTRA_FILE, ocFile);
+                getContext().startService(i);
+            } else {
+                File file = new File(ocFile.getStoragePath());
+                vCards.addAll(Ezvcard.parse(file).all());
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        final Button restoreContacts = (Button) view.findViewById(R.id.contactlist_restore_selected);
+        restoreContacts.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+
+                if (checkAndAskForContactsWritePermission()) {
+                    getAccountForImport();
+                }
+            }
+        });
+
+        ContactListAdapter contactListAdapter = new ContactListAdapter(getContext(), vCards);
+
+        listView = (ListView) view.findViewById(R.id.contactlist_listview);
+        listView.setChoiceMode(AbsListView.CHOICE_MODE_MULTIPLE);
+        listView.setAdapter(contactListAdapter);
+
+        listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+            @Override
+            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+
+                CheckedTextView tv = (CheckedTextView) view.findViewById(R.id.contactlist_item_name);
+
+                if (listView.getCheckedItemPositions().get(position)) {
+                    tv.setChecked(true);
+                } else {
+                    listView.getCheckedItemPositions().delete(position);
+                    tv.setChecked(false);
+                }
+
+                if (listView.getCheckedItemPositions().size() > 0) {
+                    restoreContacts.setEnabled(true);
+                    restoreContacts.setBackgroundColor(getResources().getColor(R.color.primary_button_background_color));
+                } else {
+                    restoreContacts.setEnabled(false);
+                    restoreContacts.setBackgroundColor(getResources().getColor(R.color.standard_grey));
+                }
+            }
+        });
+
+        return view;
+    }
+
+    static class ContactItemViewHolder {
+        QuickContactBadge badge;
+        TextView name;
+    }
+
+    private void importContacts(ContactAccount account) {
+        SparseBooleanArray checkedArray = listView.getCheckedItemPositions();
+        int[] intArray = new int[vCards.size()];
+
+        for (int i = 0; i < vCards.size(); i++) {
+            if (checkedArray.get(i)) {
+                intArray[i] = 1;
+            }
+        }
+
+        PersistableBundleCompat bundle = new PersistableBundleCompat();
+        bundle.putString(ContactsImportJob.ACCOUNT_NAME, account.name);
+        bundle.putString(ContactsImportJob.ACCOUNT_TYPE, account.type);
+        bundle.putString(ContactsImportJob.VCARD_FILE_PATH, getFile().getStoragePath());
+        bundle.putIntArray(ContactsImportJob.CHECKED_ITEMS_ARRAY, intArray);
+
+        new JobRequest.Builder(ContactsImportJob.TAG)
+                .setExtras(bundle)
+                .setExecutionWindow(3_000L, 10_000L)
+                .setRequiresCharging(false)
+                .setPersisted(false)
+                .setUpdateCurrent(false)
+                .build()
+                .schedule();
+
+
+        Snackbar.make(listView, R.string.contacts_preferences_import_scheduled, Snackbar.LENGTH_LONG).show();
+    }
+
+    private void getAccountForImport() {
+        final ArrayList<ContactAccount> accounts = new ArrayList<>();
+
+        // add local one
+        accounts.add(new ContactAccount("Local contacts", null, null));
+
+        Cursor cursor = null;
+        try {
+            cursor = getContext().getContentResolver().query(ContactsContract.RawContacts.CONTENT_URI,
+                    new String[]{ContactsContract.RawContacts.ACCOUNT_NAME, ContactsContract.RawContacts.ACCOUNT_TYPE},
+                    null,
+                    null,
+                    null);
+
+            if (cursor != null && cursor.getCount() > 0) {
+                while (cursor.moveToNext()) {
+                    String name = cursor.getString(cursor.getColumnIndex(ContactsContract.RawContacts.ACCOUNT_NAME));
+                    String type = cursor.getString(cursor.getColumnIndex(ContactsContract.RawContacts.ACCOUNT_TYPE));
+
+                    ContactAccount account = new ContactAccount(name, name, type);
+
+                    if (!accounts.contains(account)) {
+                        accounts.add(account);
+                    }
+                }
+
+                cursor.close();
+            }
+        } catch (Exception e) {
+            Log_OC.d(TAG, e.getMessage());
+        } finally {
+            cursor.close();
+        }
+
+        if (accounts.size() == 1) {
+            importContacts(accounts.get(0));
+        } else {
+
+            ArrayAdapter adapter = new ArrayAdapter<>(getContext(), android.R.layout.simple_list_item_1, accounts);
+            AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
+            builder.setTitle(R.string.contactlist_account_chooser_title)
+                    .setAdapter(adapter, new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+                            importContacts(accounts.get(which));
+                        }
+                    }).show();
+        }
+    }
+
+    private boolean checkAndAskForContactsWritePermission() {
+        // check permissions
+        if (!PermissionUtil.checkSelfPermission(getContext(), Manifest.permission.WRITE_CONTACTS)) {
+            PermissionUtil.requestWriteContactPermission(this);
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+
+        if (requestCode == PermissionUtil.PERMISSIONS_WRITE_CONTACTS) {
+            for (int index = 0; index < permissions.length; index++) {
+                if (Manifest.permission.WRITE_CONTACTS.equalsIgnoreCase(permissions[index])) {
+                    if (grantResults[index] >= 0) {
+                        getAccountForImport();
+                    } else {
+                        Snackbar.make(getView(), R.string.contactlist_no_permission, Snackbar.LENGTH_LONG).show();
+                    }
+                    break;
+                }
+            }
+        }
+    }
+
+    private class ContactAccount {
+        String displayName;
+        String name;
+        String type;
+
+        ContactAccount(String displayName, String name, String type) {
+            this.displayName = displayName;
+            this.name = name;
+            this.type = type;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if (obj instanceof ContactAccount) {
+                ContactAccount other = (ContactAccount) obj;
+                return this.name.equalsIgnoreCase(other.name) && this.type.equalsIgnoreCase(other.type);
+            } else {
+                return false;
+            }
+        }
+
+        @Override
+        public String toString() {
+            return displayName;
+        }
+    }
+}
+
+class ContactListAdapter extends ArrayAdapter<VCard> {
+    private List<VCard> vCards;
+
+    ContactListAdapter(Context context, List<VCard> vCards) {
+        super(context, 0, R.id.contactlist_item_name, vCards);
+
+        this.vCards = vCards;
+    }
+
+    @NonNull
+    @Override
+    public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
+        ContactListFragment.ContactItemViewHolder viewHolder;
+
+        if (convertView == null) {
+            convertView = LayoutInflater.from(getContext()).inflate(R.layout.contactlist_list_item, parent, false);
+            viewHolder = new ContactListFragment.ContactItemViewHolder();
+
+            viewHolder.badge = (QuickContactBadge) convertView.findViewById(R.id.contactlist_item_icon);
+            viewHolder.name = (TextView) convertView.findViewById(R.id.contactlist_item_name);
+
+            convertView.setTag(viewHolder);
+        } else {
+            viewHolder = (ContactListFragment.ContactItemViewHolder) convertView.getTag();
+        }
+
+        VCard vcard = vCards.get(position);
+
+        if (vcard != null) {
+            // photo
+            if (vcard.getPhotos().size() > 0) {
+                byte[] data = vcard.getPhotos().get(0).getData();
+
+                Drawable drawable = new BitmapDrawable(BitmapFactory.decodeByteArray(data, 0, data.length));
+
+                viewHolder.badge.setImageDrawable(drawable);
+            }
+
+            // name
+            StructuredName name = vcard.getStructuredName();
+            String first = (name.getGiven() == null) ? "" : name.getGiven() + " ";
+            String last = (name.getFamily() == null) ? "" : name.getFamily();
+            viewHolder.name.setText(first + last);
+        }
+
+        return convertView;
+    }
+}

src/main/java/com/owncloud/android/ui/activity/ContactsPreferenceActivity.java

@@ -0,0 +1,350 @@
+/**
+ * Nextcloud Android client application
+ *
+ * @author Tobias Kaminsky
+ * Copyright (C) 2017 Tobias Kaminsky
+ * Copyright (C) 2017 Nextcloud GmbH.
+ * <p>
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * at your option) any later version.
+ * <p>
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ * <p>
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.owncloud.android.ui.activity;
+
+import android.Manifest;
+import android.accounts.Account;
+import android.app.DatePickerDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.design.widget.Snackbar;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v7.widget.SwitchCompat;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.CompoundButton;
+import android.widget.DatePicker;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import com.evernote.android.job.JobManager;
+import com.evernote.android.job.JobRequest;
+import com.evernote.android.job.util.support.PersistableBundleCompat;
+import com.owncloud.android.R;
+import com.owncloud.android.datamodel.OCFile;
+import com.owncloud.android.db.PreferenceManager;
+import com.owncloud.android.lib.common.utils.Log_OC;
+import com.owncloud.android.services.ContactsBackupJob;
+import com.owncloud.android.ui.fragment.FileFragment;
+import com.owncloud.android.utils.DisplayUtils;
+import com.owncloud.android.utils.PermissionUtil;
+
+import java.util.Calendar;
+import java.util.Comparator;
+import java.util.Set;
+import java.util.Vector;
+
+/**
+ * This activity shows all settings for contact backup/restore
+ */
+
+public class ContactsPreferenceActivity extends FileActivity implements FileFragment.ContainerActivity {
+    public static final String TAG = ContactsPreferenceActivity.class.getSimpleName();
+
+    public static final String PREFERENCE_CONTACTS_AUTOMATIC_BACKUP = "PREFERENCE_CONTACTS_AUTOMATIC_BACKUP";
+    public static final String PREFERENCE_CONTACTS_LAST_BACKUP = "PREFERENCE_CONTACTS_LAST_BACKUP";
+
+    private SwitchCompat backupSwitch;
+    private SharedPreferences sharedPreferences;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.contacts_preference);
+
+        // setup toolbar
+        setupToolbar();
+
+        // setup drawer
+        setupDrawer(R.id.nav_contacts);
+
+        getSupportActionBar().setTitle(R.string.actionbar_contacts);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
+
+        backupSwitch = (SwitchCompat) findViewById(R.id.contacts_automatic_backup);
+        backupSwitch.setChecked(sharedPreferences.getBoolean(PREFERENCE_CONTACTS_AUTOMATIC_BACKUP, false));
+
+        backupSwitch.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+            @Override
+            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+                if (isChecked && checkAndAskForContactsReadPermission()) {
+                    // store value
+                    setAutomaticBackup(backupSwitch, true);
+
+                    // enable daily job
+                    startContactBackupJob(getAccount());
+                } else {
+                    setAutomaticBackup(backupSwitch, false);
+
+                    // cancel pending jobs
+                    cancelContactBackupJob(getBaseContext());
+                }
+            }
+        });
+
+        // display last backup
+        TextView lastBackup = (TextView) findViewById(R.id.contacts_last_backup_timestamp);
+        Long lastBackupTimestamp = sharedPreferences.getLong(PREFERENCE_CONTACTS_LAST_BACKUP, -1);
+
+        if (lastBackupTimestamp == -1) {
+            lastBackup.setText(R.string.contacts_preference_backup_never);
+        } else {
+            lastBackup.setText(DisplayUtils.getRelativeTimestamp(getBaseContext(), lastBackupTimestamp));
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+
+        if (requestCode == PermissionUtil.PERMISSIONS_READ_CONTACTS) {
+            for (int index = 0; index < permissions.length; index++) {
+                if (Manifest.permission.READ_CONTACTS.equalsIgnoreCase(permissions[index])) {
+                    if (grantResults[index] >= 0) {
+                        setAutomaticBackup(backupSwitch, true);
+                    } else {
+                        setAutomaticBackup(backupSwitch, false);
+                    }
+
+                    break;
+                }
+            }
+        }
+    }
+
+    public void backupContacts(View v) {
+        PersistableBundleCompat bundle = new PersistableBundleCompat();
+        bundle.putString(ContactsBackupJob.ACCOUNT, getAccount().name);
+        bundle.putBoolean(ContactsBackupJob.FORCE, true);
+
+        new JobRequest.Builder(ContactsBackupJob.TAG)
+                .setExtras(bundle)
+                .setExecutionWindow(3_000L, 10_000L)
+                .setRequiresCharging(false)
+                .setPersisted(false)
+                .setUpdateCurrent(false)
+                .build()
+                .schedule();
+
+        Snackbar.make(findViewById(R.id.contacts_linear_layout), R.string.contacts_preferences_backup_scheduled,
+                Snackbar.LENGTH_LONG).show();
+    }
+
+    private void setAutomaticBackup(SwitchCompat backupSwitch, boolean bool) {
+        backupSwitch.setChecked(bool);
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        editor.putBoolean(PREFERENCE_CONTACTS_AUTOMATIC_BACKUP, bool);
+        editor.apply();
+    }
+
+    private boolean checkAndAskForContactsReadPermission() {
+        // check permissions
+        if ((PermissionUtil.checkSelfPermission(this, Manifest.permission.READ_CONTACTS))) {
+            return true;
+        } else {
+            // Check if we should show an explanation
+            if (PermissionUtil.shouldShowRequestPermissionRationale(ContactsPreferenceActivity.this,
+                    android.Manifest.permission.READ_CONTACTS)) {
+                // Show explanation to the user and then request permission
+                Snackbar snackbar = Snackbar.make(findViewById(R.id.contacts_linear_layout), R.string.contacts_read_permission,
+                        Snackbar.LENGTH_INDEFINITE)
+                        .setAction(R.string.common_ok, new View.OnClickListener() {
+                            @Override
+                            public void onClick(View v) {
+                                PermissionUtil.requestReadContactPermission(ContactsPreferenceActivity.this);
+                            }
+                        });
+
+                DisplayUtils.colorSnackbar(this, snackbar);
+
+                snackbar.show();
+
+                return false;
+            } else {
+                // No explanation needed, request the permission.
+                PermissionUtil.requestReadContactPermission(ContactsPreferenceActivity.this);
+
+                return false;
+            }
+        }
+    }
+
+    public void openDate(View v) {
+        String backupFolderString = getResources().getString(R.string.contacts_backup_folder) + OCFile.PATH_SEPARATOR;
+        OCFile backupFolder = getStorageManager().getFileByPath(backupFolderString);
+
+        Vector<OCFile> backupFiles = getStorageManager().getFolderContent(backupFolder, false);
+
+        backupFiles.sort(new Comparator<OCFile>() {
+            @Override
+            public int compare(OCFile o1, OCFile o2) {
+                if (o1.getModificationTimestamp() == o2.getModificationTimestamp()) {
+                    return 0;
+                }
+
+                if (o1.getModificationTimestamp() > o2.getModificationTimestamp()) {
+                    return 1;
+                } else {
+                    return -1;
+                }
+            }
+        });
+
+        Calendar cal = Calendar.getInstance();
+        int year = cal.get(Calendar.YEAR);
+        int month = cal.get(Calendar.MONTH) + 1;
+        int day = cal.get(Calendar.DAY_OF_MONTH);
+        DatePickerDialog datePickerDialog = new DatePickerDialog(this, dateSetListener, year, month, day);
+        datePickerDialog.getDatePicker().setMaxDate(backupFiles.lastElement().getModificationTimestamp());
+        datePickerDialog.getDatePicker().setMinDate(backupFiles.firstElement().getModificationTimestamp());
+
+        datePickerDialog.show();
+    }
+
+    DatePickerDialog.OnDateSetListener dateSetListener = new DatePickerDialog.OnDateSetListener() {
+        @Override
+        public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
+            String backupFolderString = getResources().getString(R.string.contacts_backup_folder) + OCFile.PATH_SEPARATOR;
+            OCFile backupFolder = getStorageManager().getFileByPath(backupFolderString);
+            Vector<OCFile> backupFiles = getStorageManager().getFolderContent(backupFolder, false);
+
+            // find file with modification with date and time between 00:00 and 23:59
+            // if more than one file exists, take oldest
+            Calendar date = Calendar.getInstance();
+            date.set(year, month, dayOfMonth);
+
+            // start
+            date.set(Calendar.HOUR, 0);
+            date.set(Calendar.MINUTE, 0);
+            date.set(Calendar.SECOND, 1);
+            date.set(Calendar.MILLISECOND, 0);
+            date.set(Calendar.AM_PM, Calendar.AM);
+            Long start = date.getTimeInMillis();
+
+            // end
+            date.set(Calendar.HOUR, 23);
+            date.set(Calendar.MINUTE, 59);
+            date.set(Calendar.SECOND, 59);
+            Long end = date.getTimeInMillis();
+
+            OCFile backupToRestore = null;
+
+            for (OCFile file : backupFiles) {
+                if (start < file.getModificationTimestamp() && end > file.getModificationTimestamp()) {
+                    if (backupToRestore == null) {
+                        backupToRestore = file;
+                    } else if (backupToRestore.getModificationTimestamp() < file.getModificationTimestamp()) {
+                        backupToRestore = file;
+                    }
+                }
+            }
+
+            if (backupToRestore != null) {
+                Fragment contactListFragment = ContactListFragment.newInstance(backupToRestore, getAccount());
+
+                FragmentTransaction transaction = getSupportFragmentManager().beginTransaction();
+                transaction.replace(R.id.contacts_linear_layout, contactListFragment);
+                transaction.commit();
+            } else {
+                Toast.makeText(ContactsPreferenceActivity.this, R.string.contacts_preferences_no_file_found,
+                        Toast.LENGTH_SHORT).show();
+            }
+        }
+    };
+
+    public static void startContactBackupJob(Account account) {
+        Log_OC.d(TAG, "start daily contacts backup job");
+
+        PersistableBundleCompat bundle = new PersistableBundleCompat();
+        bundle.putString(ContactsBackupJob.ACCOUNT, account.name);
+
+        new JobRequest.Builder(ContactsBackupJob.TAG)
+                .setExtras(bundle)
+                .setRequiresCharging(false)
+                .setPersisted(true)
+                .setUpdateCurrent(true)
+                .setPeriodic(24 * 60 * 60 * 1000)
+                .build()
+                .schedule();
+    }
+
+    public static void cancelContactBackupJob(Context context) {
+        Log_OC.d(TAG, "disabling contacts backup job");
+
+        JobManager jobManager = JobManager.create(context);
+        Set<JobRequest> jobs = jobManager.getAllJobRequestsForTag(ContactsBackupJob.TAG);
+
+        for (JobRequest jobRequest : jobs) {
+            jobManager.cancel(jobRequest.getJobId());
+        }
+    }
+
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        boolean retval;
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                if (isDrawerOpen()) {
+                    closeDrawer();
+                } else {
+                    openDrawer();
+                }
+                retval = true;
+                break;
+
+            default:
+                retval = super.onOptionsItemSelected(item);
+        }
+        return retval;
+    }
+
+    @Override
+    public void showFiles(boolean onDeviceOnly) {
+        super.showFiles(onDeviceOnly);
+        Intent fileDisplayActivity = new Intent(getApplicationContext(), FileDisplayActivity.class);
+        fileDisplayActivity.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        startActivity(fileDisplayActivity);
+    }
+
+    @Override
+    public void showDetails(OCFile file) {
+
+    }
+
+    @Override
+    public void onBrowsedDownTo(OCFile folder) {
+
+    }
+
+    @Override
+    public void onTransferStateChanged(OCFile file, boolean downloading, boolean uploading) {
+
+    }
+}

src/main/java/com/owncloud/android/ui/activity/DrawerActivity.java

@@ -328,6 +328,10 @@ public abstract class DrawerActivity extends ToolbarActivity implements DisplayU
             navigationView.getMenu().removeItem(R.id.nav_shared);
         }
 
+        if (!getResources().getBoolean(R.bool.contacts_backup)) {
+            navigationView.getMenu().removeItem(R.id.nav_contacts);
+        }
+
         if (AccountUtils.hasSearchSupport(account)) {
             if (!getResources().getBoolean(R.bool.recently_added_enabled)) {
                 navigationView.getMenu().removeItem(R.id.nav_recently_added);
@@ -409,6 +413,10 @@ public abstract class DrawerActivity extends ToolbarActivity implements DisplayU
                 Intent folderSyncIntent = new Intent(getApplicationContext(), FolderSyncActivity.class);
                 startActivity(folderSyncIntent);
                 break;
+            case R.id.nav_contacts:
+                Intent contactsIntent = new Intent(getApplicationContext(), ContactsPreferenceActivity.class);
+                startActivity(contactsIntent);
+                break;
             case R.id.nav_settings:
                 Intent settingsIntent = new Intent(getApplicationContext(), Preferences.class);
                 startActivity(settingsIntent);

src/main/java/com/owncloud/android/ui/activity/FileActivity.java

@@ -28,6 +28,7 @@ import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
@@ -41,7 +42,7 @@ import com.owncloud.android.R;
 import com.owncloud.android.authentication.AccountUtils;
 import com.owncloud.android.authentication.AuthenticatorActivity;
 import com.owncloud.android.datamodel.OCFile;
-import com.owncloud.android.ui.helpers.FileOperationsHelper;
+import com.owncloud.android.db.PreferenceManager;
 import com.owncloud.android.files.services.FileDownloader;
 import com.owncloud.android.files.services.FileDownloader.FileDownloaderBinder;
 import com.owncloud.android.files.services.FileUploader;
@@ -68,6 +69,7 @@ import com.owncloud.android.services.OperationsService.OperationsServiceBinder;
 import com.owncloud.android.ui.dialog.ConfirmationDialogFragment;
 import com.owncloud.android.ui.dialog.LoadingDialog;
 import com.owncloud.android.ui.dialog.SslUntrustedCertDialog;
+import com.owncloud.android.ui.helpers.FileOperationsHelper;
 import com.owncloud.android.utils.ErrorMessageAdapter;
 
 
@@ -159,6 +161,8 @@ public abstract class FileActivity extends DrawerActivity
 
         setAccount(account, savedInstanceState != null);
 
+        checkContactsBackupJob();
+
         mOperationsServiceConnection = new OperationsServiceConnection();
         bindService(new Intent(this, OperationsService.class), mOperationsServiceConnection,
                 Context.BIND_AUTO_CREATE);
@@ -234,6 +238,16 @@ public abstract class FileActivity extends DrawerActivity
         }
     }
 
+    private void checkContactsBackupJob() {
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(getBaseContext());
+
+        if (sharedPreferences.getBoolean(ContactsPreferenceActivity.PREFERENCE_CONTACTS_AUTOMATIC_BACKUP, false)) {
+            ContactsPreferenceActivity.startContactBackupJob(getAccount());
+        } else {
+            ContactsPreferenceActivity.cancelContactBackupJob(getBaseContext());
+        }
+    }
+
 
     /**
      * Getter for the main {@link OCFile} handled by the activity.

src/main/java/com/owncloud/android/ui/activity/FileDisplayActivity.java

@@ -96,6 +96,7 @@ import com.owncloud.android.ui.preview.PreviewVideoActivity;
 import com.owncloud.android.utils.DataHolderUtil;
 import com.owncloud.android.utils.DisplayUtils;
 import com.owncloud.android.utils.ErrorMessageAdapter;
+import com.owncloud.android.utils.MimeTypeUtil;
 import com.owncloud.android.utils.PermissionUtil;
 
 import java.io.File;
@@ -141,7 +142,7 @@ public class FileDisplayActivity extends HookActivity
     private static final String TAG = FileDisplayActivity.class.getSimpleName();
 
     private static final String TAG_LIST_OF_FILES = "LIST_OF_FILES";
-    private static final String TAG_SECOND_FRAGMENT = "SECOND_FRAGMENT";
+    public static final String TAG_SECOND_FRAGMENT = "SECOND_FRAGMENT";
 
     private OCFile mWaitingToPreview;
 
@@ -170,10 +171,10 @@ public class FileDisplayActivity extends HookActivity
 
         /// Load of saved instance state
         if (savedInstanceState != null) {
-            mWaitingToPreview = (OCFile) savedInstanceState.getParcelable(
+            mWaitingToPreview = savedInstanceState.getParcelable(
                     FileDisplayActivity.KEY_WAITING_TO_PREVIEW);
             mSyncInProgress = savedInstanceState.getBoolean(KEY_SYNC_IN_PROGRESS);
-            mWaitingToSend = (OCFile) savedInstanceState.getParcelable(
+            mWaitingToSend = savedInstanceState.getParcelable(
                     FileDisplayActivity.KEY_WAITING_TO_SEND);
             searchQuery = savedInstanceState.getString(KEY_SEARCH_QUERY);
         } else {
@@ -222,7 +223,7 @@ public class FileDisplayActivity extends HookActivity
     protected void onPostCreate(Bundle savedInstanceState) {
         super.onPostCreate(savedInstanceState);
 
-        if (PermissionUtil.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
+        if (!PermissionUtil.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
             // Check if we should show an explanation
             if (PermissionUtil.shouldShowRequestPermissionRationale(this,
                     Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
@@ -323,6 +324,8 @@ public class FileDisplayActivity extends HookActivity
                 }
                 return;
             }
+            default:
+                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
         }
     }
 
@@ -406,7 +409,9 @@ public class FileDisplayActivity extends HookActivity
                 updateActionBarTitleAndHomeButton(file);
             } else {
                 cleanSecondFragment();
-                if (file.isDown() && PreviewTextFragment.canBePreviewed(file)) {
+                if (file.isDown() && MimeTypeUtil.isVCard(file.getMimetype())){
+                    startContactListFragment(file);
+                } else if (file.isDown() && PreviewTextFragment.canBePreviewed(file)) {
                     startTextPreview(file);
                 }
             }
@@ -563,6 +568,9 @@ public class FileDisplayActivity extends HookActivity
                         if (PreviewMediaFragment.canBePreviewed(mWaitingToPreview)) {
                             startMediaPreview(mWaitingToPreview, 0, true);
                             detailsFragmentChanged = true;
+                        } else if (MimeTypeUtil.isVCard(mWaitingToPreview.getMimetype())){
+                            startContactListFragment(mWaitingToPreview);
+                            detailsFragmentChanged = true;
                         } else if (PreviewTextFragment.canBePreviewed(mWaitingToPreview)) {
                             startTextPreview(mWaitingToPreview);
                             detailsFragmentChanged = true;
@@ -1901,6 +1909,15 @@ public class FileDisplayActivity extends HookActivity
         setFile(file);
     }
 
+    public void startContactListFragment(OCFile file) {
+        Fragment contactListFragment = ContactListFragment.newInstance(file, getAccount());
+
+        setSecondFragment(contactListFragment);
+        updateFragmentsVisibility(true);
+        updateActionBarTitleAndHomeButton(file);
+        setFile(file);
+    }
+
     /**
      * Requests the download of the received {@link OCFile} , updates the UI
      * to monitor the download progress and prepares the activity to preview

src/main/java/com/owncloud/android/ui/fragment/ExtendedListFragment.java

@@ -282,14 +282,24 @@ public class ExtendedListFragment extends Fragment
     }
 
     public boolean onQueryTextChange(final String query) {
-        performSearch(query, false);
-        return true;
+        if (getFragmentManager().findFragmentByTag(FileDisplayActivity.TAG_SECOND_FRAGMENT)
+                instanceof ExtendedListFragment){
+            performSearch(query, false);
+            return true;
+        } else {
+            return false;
+        }
     }
 
     @Override
     public boolean onQueryTextSubmit(String query) {
-        performSearch(query, true);
-        return true;
+        if (getFragmentManager().findFragmentByTag(FileDisplayActivity.TAG_SECOND_FRAGMENT)
+                instanceof ExtendedListFragment){
+            performSearch(query, true);
+            return true;
+        } else {
+            return false;
+        }
     }
 
     private void performSearch(final String query, boolean isSubmit) {

src/main/java/com/owncloud/android/ui/fragment/OCFileListFragment.java

@@ -89,6 +89,7 @@ import com.owncloud.android.ui.preview.PreviewMediaFragment;
 import com.owncloud.android.ui.preview.PreviewTextFragment;
 import com.owncloud.android.utils.DisplayUtils;
 import com.owncloud.android.utils.FileStorageUtils;
+import com.owncloud.android.utils.MimeTypeUtil;
 
 import org.greenrobot.eventbus.EventBus;
 import org.greenrobot.eventbus.Subscribe;
@@ -799,6 +800,8 @@ public class OCFileListFragment extends ExtendedListFragment implements OCFileLi
                 if (PreviewImageFragment.canBePreviewed(file)) {
                     // preview image - it handles the download, if needed
                     ((FileDisplayActivity) mContainerActivity).startImagePreview(file);
+                } else if (file.isDown() && MimeTypeUtil.isVCard(file)){
+                    ((FileDisplayActivity) mContainerActivity).startContactListFragment(file);
                 } else if (PreviewTextFragment.canBePreviewed(file)) {
                     ((FileDisplayActivity) mContainerActivity).startTextPreview(file);
                 } else if (file.isDown()) {

src/main/java/com/owncloud/android/utils/MimeTypeUtil.java

@@ -149,6 +149,13 @@ public class MimeTypeUtil {
         return (mimeType != null && mimeType.toLowerCase().startsWith("text/"));
     }
 
+    /**
+     * @return 'True' if mime type defines vcard
+     */
+    public static boolean isVCard(String mimeType) {
+        return "text/vcard".equalsIgnoreCase(mimeType);
+    }
+
     /**
      * Checks if file passed is a video.
      *
@@ -203,6 +210,15 @@ public class MimeTypeUtil {
                 || MimeTypeUtil.isText(getMimeTypeFromPath(file.getRemotePath())));
     }
 
+
+    /**
+     * @param file the file to be analyzed
+     * @return 'True' if the file is a vcard
+     */
+    public static boolean isVCard(OCFile file) {
+        return isVCard(file.getMimetype()) || isVCard(getMimeTypeFromPath(file.getRemotePath()));
+    }
+
     /**
      * Extracts the mime type for the given file.
      *

src/main/java/com/owncloud/android/utils/PermissionUtil.java

@@ -11,6 +11,8 @@ import android.support.v4.content.ContextCompat;
  */
 public class PermissionUtil {
     public static final int PERMISSIONS_WRITE_EXTERNAL_STORAGE = 1;
+    public static final int PERMISSIONS_READ_CONTACTS = 2;
+    public static final int PERMISSIONS_WRITE_CONTACTS = 3;
 
     /**
      * Wrapper method for ContextCompat.checkSelfPermission().
@@ -22,7 +24,7 @@ public class PermissionUtil {
      */
     public static boolean checkSelfPermission(Context context, String permission) {
         return ContextCompat.checkSelfPermission(context, permission)
-                != android.content.pm.PackageManager.PERMISSION_GRANTED;
+                == android.content.pm.PackageManager.PERMISSION_GRANTED;
     }
 
     /**
@@ -50,4 +52,36 @@ public class PermissionUtil {
                 new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                 PERMISSIONS_WRITE_EXTERNAL_STORAGE);
     }
+
+    /**
+     * request the read permission for contacts
+     *
+     * @param activity The target activity.
+     */
+    public static void requestReadContactPermission(Activity activity) {
+        ActivityCompat.requestPermissions(activity,
+                new String[]{Manifest.permission.READ_CONTACTS},
+                PERMISSIONS_READ_CONTACTS);
+    }
+
+    /**
+     * request the write permission for contacts
+     *
+     * @param activity The target activity.
+     */
+    public static void requestWriteContactPermission(Activity activity) {
+        ActivityCompat.requestPermissions(activity,
+                new String[]{Manifest.permission.WRITE_CONTACTS},
+                PERMISSIONS_WRITE_CONTACTS);
+    }
+
+    /**
+     * request the write permission for contacts
+     *
+     * @param fragment The target fragment.
+     */
+    public static void requestWriteContactPermission(android.support.v4.app.Fragment fragment) {
+        fragment.requestPermissions(new String[]{Manifest.permission.WRITE_CONTACTS},
+                PERMISSIONS_WRITE_CONTACTS);
+    }
 }

src/main/java/third_parties/ezvcard_android/AndroidCustomField.java

@@ -0,0 +1,114 @@
+package third_parties.ezvcard_android;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import ezvcard.property.VCardProperty;
+
+/*
+ Copyright (c) 2014-2015, Michael Angstadt
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ The views and conclusions contained in the software and documentation are those
+ of the authors and should not be interpreted as representing official policies,
+ either expressed or implied, of the FreeBSD Project.
+ */
+
+/**
+ * Represents an "X-ANDROID-CUSTOM" property.
+ * @author Michael Angstadt
+ */
+public class AndroidCustomField extends VCardProperty {
+    private String type;
+    private boolean dir;
+    private List<String> values = new ArrayList<String>();
+
+    /**
+     * Creates an "item" field.
+     * @param type the type
+     * @param value the value
+     * @return the property
+     */
+    public static AndroidCustomField item(String type, String value) {
+        AndroidCustomField property = new AndroidCustomField();
+        property.dir = false;
+        property.type = type;
+        property.values.add(value);
+        return property;
+    }
+
+    /**
+     * Creates a "dir" field.
+     * @param type the type
+     * @param values the values
+     * @return the property
+     */
+    public static AndroidCustomField dir(String type, String... values) {
+        AndroidCustomField property = new AndroidCustomField();
+        property.dir = true;
+        property.type = type;
+        Collections.addAll(property.values, values);
+        return property;
+    }
+
+    public String getType() {
+        return type;
+    }
+
+    public void setType(String type) {
+        this.type = type;
+    }
+
+    public List<String> getValues() {
+        return values;
+    }
+
+    public boolean isDir() {
+        return dir;
+    }
+
+    public void setDir(boolean dir) {
+        this.dir = dir;
+    }
+
+    public boolean isItem() {
+        return !isDir();
+    }
+
+    public void setItem(boolean item) {
+        setDir(!item);
+    }
+
+    public boolean isNickname() {
+        return "nickname".equals(type);
+    }
+
+    public boolean isContactEvent() {
+        return "contact_event".equals(type);
+    }
+
+    public boolean isRelation() {
+        return "relation".equals(type);
+    }
+}

src/main/java/third_parties/ezvcard_android/ContactOperations.java

@@ -0,0 +1,567 @@
+package third_parties.ezvcard_android;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import ezvcard.VCard;
+import ezvcard.property.Address;
+import ezvcard.property.Birthday;
+import ezvcard.property.Email;
+import ezvcard.property.FormattedName;
+import ezvcard.property.Impp;
+import ezvcard.property.Nickname;
+import ezvcard.property.Note;
+import ezvcard.property.Organization;
+import ezvcard.property.Photo;
+import ezvcard.property.RawProperty;
+import ezvcard.property.StructuredName;
+import ezvcard.property.Telephone;
+import ezvcard.property.Title;
+import ezvcard.property.Url;
+import ezvcard.property.VCardProperty;
+import ezvcard.util.TelUri;
+
+import static android.text.TextUtils.isEmpty;
+
+/*
+ Copyright (c) 2014-2015, Michael Angstadt
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ The views and conclusions contained in the software and documentation are those
+ of the authors and should not be interpreted as representing official policies,
+ either expressed or implied, of the FreeBSD Project.
+ */
+
+/**
+ * Inserts a {@link VCard} into an Android database.
+ *
+ * @author Pratyush
+ * @author Michael Angstadt
+ */
+public class ContactOperations {
+    private static final int rawContactID = 0;
+
+    private final Context context;
+    private final NonEmptyContentValues account;
+
+    public ContactOperations(Context context) {
+        this(context, null, null);
+    }
+
+    public ContactOperations(Context context, String accountName, String accountType) {
+        this.context = context;
+
+        account = new NonEmptyContentValues();
+        account.put(ContactsContract.RawContacts.ACCOUNT_TYPE, accountType);
+        account.put(ContactsContract.RawContacts.ACCOUNT_NAME, accountName);
+    }
+
+    public void insertContact(VCard vcard) throws RemoteException, OperationApplicationException {
+        // TODO handle Raw properties - Raw properties include various extension which start with "X-" like X-ASSISTANT, X-AIM, X-SPOUSE
+
+        List<NonEmptyContentValues> contentValues = new ArrayList<NonEmptyContentValues>();
+        convertName(contentValues, vcard);
+        convertNickname(contentValues, vcard);
+        convertPhones(contentValues, vcard);
+        convertEmails(contentValues, vcard);
+        convertAddresses(contentValues, vcard);
+        convertIms(contentValues, vcard);
+
+        // handle Android Custom fields..This is only valid for Android generated Vcards. As the Android would
+        // generate NickName, ContactEvents other than Birthday and RelationShip with this "X-ANDROID-CUSTOM" name
+        convertCustomFields(contentValues, vcard);
+
+        // handle Iphone kinda of group properties. which are grouped together.
+        convertGroupedProperties(contentValues, vcard);
+
+        convertBirthdays(contentValues, vcard);
+
+        convertWebsites(contentValues, vcard);
+        convertNotes(contentValues, vcard);
+        convertPhotos(contentValues, vcard);
+        convertOrganization(contentValues, vcard);
+
+        ArrayList<ContentProviderOperation> operations = new ArrayList<ContentProviderOperation>(contentValues.size());
+        ContentValues cv = account.getContentValues();
+        //ContactsContract.RawContact.CONTENT_URI needed to add account, backReference is also not needed
+        ContentProviderOperation operation =
+                ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
+                        .withValues(cv)
+                        .build();
+        operations.add(operation);
+        for (NonEmptyContentValues values : contentValues) {
+            cv = values.getContentValues();
+            if (cv.size() == 0) {
+                continue;
+            }
+
+            //@formatter:off
+            operation =
+                    ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
+                            .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, rawContactID)
+                            .withValues(cv)
+                            .build();
+            //@formatter:on
+            operations.add(operation);
+        }
+
+        // Executing all the insert operations as a single database transaction
+        context.getContentResolver().applyBatch(ContactsContract.AUTHORITY, operations);
+    }
+
+    private void convertName(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        NonEmptyContentValues values = new NonEmptyContentValues(ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
+
+        String firstName = null, lastName = null, namePrefix = null, nameSuffix = null;
+        StructuredName n = vcard.getStructuredName();
+        if (n != null) {
+            firstName = n.getGiven();
+            values.put(ContactsContract.CommonDataKinds.StructuredName.GIVEN_NAME, firstName);
+
+            lastName = n.getFamily();
+            values.put(ContactsContract.CommonDataKinds.StructuredName.FAMILY_NAME, lastName);
+
+            List<String> prefixes = n.getPrefixes();
+            if (!prefixes.isEmpty()) {
+                namePrefix = prefixes.get(0);
+                values.put(ContactsContract.CommonDataKinds.StructuredName.PREFIX, namePrefix);
+            }
+
+            List<String> suffixes = n.getSuffixes();
+            if (!suffixes.isEmpty()) {
+                nameSuffix = suffixes.get(0);
+                values.put(ContactsContract.CommonDataKinds.StructuredName.SUFFIX, nameSuffix);
+            }
+        }
+
+        FormattedName fn = vcard.getFormattedName();
+        String formattedName = (fn == null) ? null : fn.getValue();
+
+        String displayName;
+        if (isEmpty(formattedName)) {
+            StringBuilder sb = new StringBuilder();
+            if (!isEmpty(namePrefix)){
+                sb.append(namePrefix).append(' ');
+            }
+            if (!isEmpty(firstName)){
+                sb.append(firstName).append(' ');
+            }
+            if (!isEmpty(lastName)){
+                sb.append(lastName).append(' ');
+            }
+            if (!isEmpty(nameSuffix)){
+                if (sb.length() > 0){
+                    sb.deleteCharAt(sb.length()-1); //delete space character
+                    sb.append(", ");
+                }
+                sb.append(nameSuffix);
+            }
+
+            displayName = sb.toString().trim();
+        } else {
+            displayName = formattedName;
+        }
+        values.put(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, displayName);
+
+        RawProperty xPhoneticFirstName = vcard.getExtendedProperty("X-PHONETIC-FIRST-NAME");
+        String firstPhoneticName = (xPhoneticFirstName == null) ? null : xPhoneticFirstName.getValue();
+        values.put(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_GIVEN_NAME, firstPhoneticName);
+
+        RawProperty xPhoneticLastName = vcard.getExtendedProperty("X-PHONETIC-LAST-NAME");
+        String lastPhoneticName = (xPhoneticLastName == null) ? null : xPhoneticLastName.getValue();
+        values.put(ContactsContract.CommonDataKinds.StructuredName.PHONETIC_FAMILY_NAME, lastPhoneticName);
+
+        contentValues.add(values);
+    }
+
+    private void convertNickname(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Nickname nickname : vcard.getNicknames()) {
+            List<String> nicknameValues = nickname.getValues();
+            if (nicknameValues.isEmpty()) {
+                continue;
+            }
+
+            for (String nicknameValue : nicknameValues) {
+                NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Nickname.CONTENT_ITEM_TYPE);
+                cv.put(ContactsContract.CommonDataKinds.Nickname.NAME, nicknameValue);
+                contentValues.add(cv);
+            }
+        }
+    }
+
+    private void convertPhones(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Telephone telephone : vcard.getTelephoneNumbers()) {
+            String value = telephone.getText();
+            TelUri uri = telephone.getUri();
+            if (isEmpty(value)) {
+                if (uri == null) {
+                    continue;
+                }
+                value = uri.toString();
+            }
+
+            int phoneKind = DataMappings.getPhoneType(telephone);
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Phone.NUMBER, value);
+            cv.put(ContactsContract.CommonDataKinds.Phone.TYPE, phoneKind);
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertEmails(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Email email : vcard.getEmails()) {
+            String value = email.getValue();
+            if (isEmpty(value)) {
+                continue;
+            }
+
+            int emailKind = DataMappings.getEmailType(email);
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Email.ADDRESS, value);
+            cv.put(ContactsContract.CommonDataKinds.Email.TYPE, emailKind);
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertAddresses(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Address address : vcard.getAddresses()) {
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.StructuredPostal.CONTENT_ITEM_TYPE);
+
+            String street = address.getStreetAddress();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.STREET, street);
+
+            String poBox = address.getPoBox();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.POBOX, poBox);
+
+            String city = address.getLocality();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.CITY, city);
+
+            String state = address.getRegion();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.REGION, state);
+
+            String zipCode = address.getPostalCode();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.POSTCODE, zipCode);
+
+            String country = address.getCountry();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.COUNTRY, country);
+
+            String label = address.getLabel();
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.LABEL, label);
+
+            int addressKind = DataMappings.getAddressType(address);
+            cv.put(ContactsContract.CommonDataKinds.StructuredPostal.TYPE, addressKind);
+
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertIms(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        //handle extended properties
+        for (Map.Entry<String, Integer> entry : DataMappings.getImPropertyNameMappings().entrySet()) {
+            String propertyName = entry.getKey();
+            Integer protocolType = entry.getValue();
+            List<RawProperty> rawProperties = vcard.getExtendedProperties(propertyName);
+            for (RawProperty rawProperty : rawProperties) {
+                NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Im.CONTENT_ITEM_TYPE);
+
+                String value = rawProperty.getValue();
+                cv.put(ContactsContract.CommonDataKinds.Im.DATA, value);
+
+                cv.put(ContactsContract.CommonDataKinds.Im.PROTOCOL, protocolType);
+
+                contentValues.add(cv);
+            }
+        }
+
+        //handle IMPP properties
+        for (Impp impp : vcard.getImpps()) {
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Im.CONTENT_ITEM_TYPE);
+
+            String immpAddress = impp.getHandle();
+            cv.put(ContactsContract.CommonDataKinds.Im.DATA, immpAddress);
+
+            int immpProtocolType = DataMappings.getIMTypeFromProtocol(impp.getProtocol());
+            cv.put(ContactsContract.CommonDataKinds.Im.PROTOCOL, immpProtocolType);
+
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertCustomFields(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (AndroidCustomField customField : vcard.getProperties(AndroidCustomField.class)) {
+            List<String> values = customField.getValues();
+            if (values.isEmpty()) {
+                continue;
+            }
+
+            NonEmptyContentValues cv;
+            if (customField.isNickname()) {
+                cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Nickname.CONTENT_ITEM_TYPE);
+                cv.put(ContactsContract.CommonDataKinds.Nickname.NAME, values.get(0));
+            } else if (customField.isContactEvent()) {
+                cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE);
+                cv.put(ContactsContract.CommonDataKinds.Event.START_DATE, values.get(0));
+                cv.put(ContactsContract.CommonDataKinds.Event.TYPE, values.get(1));
+            } else if (customField.isRelation()) {
+                cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Relation.CONTENT_ITEM_TYPE);
+                cv.put(ContactsContract.CommonDataKinds.Relation.NAME, values.get(0));
+                cv.put(ContactsContract.CommonDataKinds.Relation.TYPE, values.get(1));
+            } else {
+                continue;
+            }
+
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertGroupedProperties(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        List<RawProperty> extendedProperties = vcard.getExtendedProperties();
+        Map<String, List<RawProperty>> orderedByGroup = orderPropertiesByGroup(extendedProperties);
+        final int ABDATE = 1, ABRELATEDNAMES = 2;
+
+        for (List<RawProperty> properties : orderedByGroup.values()) {
+            if (properties.size() == 1) {
+                continue;
+            }
+
+            String label = null;
+            String val = null;
+            int mime = 0;
+            for (RawProperty property : properties) {
+                String name = property.getPropertyName();
+
+                if (name.equalsIgnoreCase("X-ABDATE")) {
+                    label = property.getValue(); //date
+                    mime = ABDATE;
+                    continue;
+                }
+
+                if (name.equalsIgnoreCase("X-ABRELATEDNAMES")) {
+                    label = property.getValue(); //name
+                    mime = ABRELATEDNAMES;
+                    continue;
+                }
+
+                if (name.equalsIgnoreCase("X-ABLABEL")) {
+                    val = property.getValue(); // type of value ..Birthday,anniversary
+                    continue;
+                }
+            }
+
+            NonEmptyContentValues cv = null;
+            switch (mime) {
+                case ABDATE:
+                    cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE);
+
+                    cv.put(ContactsContract.CommonDataKinds.Event.START_DATE, label);
+
+                    int type = DataMappings.getDateType(val);
+                    cv.put(ContactsContract.CommonDataKinds.Event.TYPE, type);
+
+                    break;
+
+                case ABRELATEDNAMES:
+                    if (val != null) {
+                        cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Nickname.CONTENT_ITEM_TYPE);
+                        cv.put(ContactsContract.CommonDataKinds.Nickname.NAME, label);
+
+                        if (!val.equals("Nickname")) {
+                            type = DataMappings.getNameType(val);
+                            cv.put(ContactsContract.CommonDataKinds.Relation.TYPE, type);
+                        }
+                    }
+
+                    break;
+
+                default:
+                    continue;
+            }
+
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertBirthdays(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
+        for (Birthday birthday : vcard.getBirthdays()) {
+            Date date = birthday.getDate();
+            if (date == null) {
+                continue;
+            }
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Event.TYPE, ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY);
+            cv.put(ContactsContract.CommonDataKinds.Event.START_DATE, df.format(date));
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertWebsites(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Url url : vcard.getUrls()) {
+            String urlValue = url.getValue();
+            if (isEmpty(urlValue)) {
+                continue;
+            }
+
+            int type = DataMappings.getWebSiteType(url.getType());
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Website.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Website.URL, urlValue);
+            cv.put(ContactsContract.CommonDataKinds.Website.TYPE, type);
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertNotes(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Note note : vcard.getNotes()) {
+            String noteValue = note.getValue();
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Note.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Note.NOTE, noteValue);
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertPhotos(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        for (Photo photo : vcard.getPhotos()) {
+            byte[] data = photo.getData();
+
+            NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Photo.CONTENT_ITEM_TYPE);
+            cv.put(ContactsContract.CommonDataKinds.Photo.PHOTO, data);
+            contentValues.add(cv);
+        }
+    }
+
+    private void convertOrganization(List<NonEmptyContentValues> contentValues, VCard vcard) {
+        NonEmptyContentValues cv = new NonEmptyContentValues(ContactsContract.CommonDataKinds.Organization.CONTENT_ITEM_TYPE);
+
+        Organization organization = vcard.getOrganization();
+        if (organization != null) {
+            List<String> values = organization.getValues();
+            String keys[] = { ContactsContract.CommonDataKinds.Organization.COMPANY, ContactsContract.CommonDataKinds.Organization.DEPARTMENT, ContactsContract.CommonDataKinds.Organization.OFFICE_LOCATION };
+            for (int i = 0; i < values.size(); i++) {
+                String key = keys[i];
+                String value = values.get(i);
+                cv.put(key, value);
+            }
+        }
+
+        List<Title> titleList = vcard.getTitles();
+        if (!titleList.isEmpty()) {
+            cv.put(ContactsContract.CommonDataKinds.Organization.TITLE, titleList.get(0).getValue());
+        }
+
+        contentValues.add(cv);
+    }
+
+    /**
+     * Groups properties by their group name.
+     * @param properties the properties to group
+     * @return a map where the key is the group name (null for no group) and the
+     * value is the list of properties that belong to that group
+     */
+    private <T extends VCardProperty> Map<String, List<T>> orderPropertiesByGroup(List<T> properties) {
+        Map<String, List<T>> groupedProperties = new HashMap<String, List<T>>();
+
+        for (T property : properties) {
+            String group = property.getGroup();
+            if (isEmpty(group)) {
+                continue;
+            }
+
+            List<T> groupPropertiesList = groupedProperties.get(group);
+            if (groupPropertiesList == null) {
+                groupPropertiesList = new ArrayList<T>();
+                groupedProperties.put(group, groupPropertiesList);
+            }
+            groupPropertiesList.add(property);
+        }
+
+        return groupedProperties;
+    }
+
+    /**
+     * A wrapper for {@link ContentValues} that only adds values which are
+     * non-null and non-empty (in the case of Strings).
+     */
+    private static class NonEmptyContentValues {
+        private final ContentValues contentValues = new ContentValues();
+        private final String contentItemType;
+
+        public NonEmptyContentValues() {
+            this(null);
+        }
+
+        /**
+         * @param contentItemType the MIME type (value of
+         * {@link ContactsContract.Contacts.Data#MIMETYPE})
+         */
+        public NonEmptyContentValues(String contentItemType) {
+            this.contentItemType = contentItemType;
+        }
+
+        public void put(String key, String value) {
+            if (isEmpty(value)) {
+                return;
+            }
+            contentValues.put(key, value);
+        }
+
+        public void put(String key, int value) {
+            contentValues.put(key, value);
+        }
+
+        public void put(String key, byte[] value) {
+            if (value == null) {
+                return;
+            }
+            contentValues.put(key, value);
+        }
+
+        /**
+         * Gets the wrapped {@link ContentValues} object, adding the MIME type
+         * entry if the values map is not empty.
+         * @return the wrapped {@link ContentValues} object
+         */
+        public ContentValues getContentValues() {
+            if (contentValues.size() > 0 && contentItemType != null) {
+                put(ContactsContract.Contacts.Data.MIMETYPE, contentItemType);
+            }
+            return contentValues;
+        }
+    }
+}

src/main/java/third_parties/ezvcard_android/DataMappings.java

@@ -0,0 +1,292 @@
+package third_parties.ezvcard_android;
+
+import android.provider.ContactsContract;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import ezvcard.parameter.AddressType;
+import ezvcard.parameter.EmailType;
+import ezvcard.parameter.TelephoneType;
+import ezvcard.property.Address;
+import ezvcard.property.Email;
+import ezvcard.property.Impp;
+import ezvcard.property.Telephone;
+
+/*
+ Copyright (c) 2014-2015, Michael Angstadt
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ The views and conclusions contained in the software and documentation are those
+ of the authors and should not be interpreted as representing official policies,
+ either expressed or implied, of the FreeBSD Project.
+ */
+
+/**
+ * Maps between vCard contact data types and Android {@link ContactsContract}
+ * data types.
+ *
+ * @author Pratyush
+ * @author Julien Garrigou
+ * @author Michael Angstadt
+ */
+public class DataMappings {
+    private static final Map<TelephoneType, Integer> phoneTypeMappings;
+    static {
+        Map<TelephoneType, Integer> m = new HashMap<TelephoneType, Integer>();
+        m.put(TelephoneType.BBS, ContactsContract.CommonDataKinds.Phone.TYPE_CUSTOM);
+        m.put(TelephoneType.CAR, ContactsContract.CommonDataKinds.Phone.TYPE_CAR);
+        m.put(TelephoneType.CELL, ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE);
+        m.put(TelephoneType.FAX, ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME);
+        m.put(TelephoneType.HOME, ContactsContract.CommonDataKinds.Phone.TYPE_HOME);
+        m.put(TelephoneType.ISDN, ContactsContract.CommonDataKinds.Phone.TYPE_ISDN);
+        m.put(TelephoneType.MODEM, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER);
+        m.put(TelephoneType.PAGER, ContactsContract.CommonDataKinds.Phone.TYPE_PAGER);
+        m.put(TelephoneType.MSG, ContactsContract.CommonDataKinds.Phone.TYPE_MMS);
+        m.put(TelephoneType.PCS, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER);
+        m.put(TelephoneType.TEXT, ContactsContract.CommonDataKinds.Phone.TYPE_MMS);
+        m.put(TelephoneType.TEXTPHONE, ContactsContract.CommonDataKinds.Phone.TYPE_MMS);
+        m.put(TelephoneType.VIDEO, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER);
+        m.put(TelephoneType.WORK, ContactsContract.CommonDataKinds.Phone.TYPE_WORK);
+        m.put(TelephoneType.VOICE, ContactsContract.CommonDataKinds.Phone.TYPE_OTHER);
+        phoneTypeMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<String, Integer> websiteTypeMappings;
+    static {
+        Map<String, Integer> m = new HashMap<String, Integer>();
+        m.put("home", ContactsContract.CommonDataKinds.Website.TYPE_HOME);
+        m.put("work", ContactsContract.CommonDataKinds.Website.TYPE_WORK);
+        m.put("homepage", ContactsContract.CommonDataKinds.Website.TYPE_HOMEPAGE);
+        m.put("profile", ContactsContract.CommonDataKinds.Website.TYPE_PROFILE);
+        websiteTypeMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<EmailType, Integer> emailTypeMappings;
+    static {
+        Map<EmailType, Integer> m = new HashMap<EmailType, Integer>();
+        m.put(EmailType.HOME, ContactsContract.CommonDataKinds.Email.TYPE_HOME);
+        m.put(EmailType.WORK, ContactsContract.CommonDataKinds.Email.TYPE_WORK);
+        emailTypeMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<AddressType, Integer> addressTypeMappings;
+    static {
+        Map<AddressType, Integer> m = new HashMap<AddressType, Integer>();
+        m.put(AddressType.HOME, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME);
+        m.put(AddressType.get("business"), ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK);
+        m.put(AddressType.WORK, ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK);
+        m.put(AddressType.get("other"), ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER);
+        addressTypeMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<String, Integer> abRelatedNamesMappings;
+    static {
+        Map<String, Integer> m = new HashMap<String, Integer>();
+        m.put("father", ContactsContract.CommonDataKinds.Relation.TYPE_FATHER);
+        m.put("spouse", ContactsContract.CommonDataKinds.Relation.TYPE_SPOUSE);
+        m.put("mother", ContactsContract.CommonDataKinds.Relation.TYPE_MOTHER);
+        m.put("brother", ContactsContract.CommonDataKinds.Relation.TYPE_BROTHER);
+        m.put("parent", ContactsContract.CommonDataKinds.Relation.TYPE_PARENT);
+        m.put("sister", ContactsContract.CommonDataKinds.Relation.TYPE_SISTER);
+        m.put("child", ContactsContract.CommonDataKinds.Relation.TYPE_CHILD);
+        m.put("assistant", ContactsContract.CommonDataKinds.Relation.TYPE_ASSISTANT);
+        m.put("partner", ContactsContract.CommonDataKinds.Relation.TYPE_PARTNER);
+        m.put("manager", ContactsContract.CommonDataKinds.Relation.TYPE_MANAGER);
+        abRelatedNamesMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<String, Integer> abDateMappings;
+    static {
+        Map<String, Integer> m = new HashMap<String, Integer>();
+        m.put("anniversary", ContactsContract.CommonDataKinds.Event.TYPE_ANNIVERSARY);
+        m.put("other", ContactsContract.CommonDataKinds.Event.TYPE_OTHER);
+        abDateMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<String, Integer> imPropertyNameMappings;
+    static{
+        Map<String, Integer> m = new HashMap<String, Integer>();
+        m.put("X-AIM", ContactsContract.CommonDataKinds.Im.PROTOCOL_AIM);
+        m.put("X-ICQ", ContactsContract.CommonDataKinds.Im.PROTOCOL_ICQ);
+        m.put("X-QQ", ContactsContract.CommonDataKinds.Im.PROTOCOL_ICQ);
+        m.put("X-GOOGLE-TALK", ContactsContract.CommonDataKinds.Im.PROTOCOL_CUSTOM);
+        m.put("X-JABBER", ContactsContract.CommonDataKinds.Im.PROTOCOL_JABBER);
+        m.put("X-MSN", ContactsContract.CommonDataKinds.Im.PROTOCOL_MSN);
+        m.put("X-MS-IMADDRESS", ContactsContract.CommonDataKinds.Im.PROTOCOL_MSN);
+        m.put("X-YAHOO", ContactsContract.CommonDataKinds.Im.PROTOCOL_YAHOO);
+        m.put("X-SKYPE", ContactsContract.CommonDataKinds.Im.PROTOCOL_SKYPE);
+        m.put("X-SKYPE-USERNAME", ContactsContract.CommonDataKinds.Im.PROTOCOL_SKYPE);
+        m.put("X-TWITTER", ContactsContract.CommonDataKinds.Im.PROTOCOL_CUSTOM);
+        imPropertyNameMappings = Collections.unmodifiableMap(m);
+    }
+
+    private static final Map<String, Integer> imProtocolMappings;
+    static{
+        Map<String, Integer> m = new HashMap<String, Integer>();
+        m.put("aim", ContactsContract.CommonDataKinds.Im.PROTOCOL_AIM);
+        m.put("icq", ContactsContract.CommonDataKinds.Im.PROTOCOL_ICQ);
+        m.put("msn", ContactsContract.CommonDataKinds.Im.PROTOCOL_MSN);
+        m.put("ymsgr", ContactsContract.CommonDataKinds.Im.PROTOCOL_YAHOO);
+        m.put("skype", ContactsContract.CommonDataKinds.Im.PROTOCOL_SKYPE);
+        imProtocolMappings = Collections.unmodifiableMap(m);
+    }
+
+    /**
+     * Maps the value of a URL property's TYPE parameter to the appropriate
+     * Android {@link ContactsContract.CommonDataKinds.Website} value.
+     * @param type the TYPE parameter value (can be null)
+     * @return the Android type
+     */
+    public static int getWebSiteType(String type) {
+        if (type == null){
+            return ContactsContract.CommonDataKinds.Website.TYPE_CUSTOM;
+        }
+
+        type = type.toLowerCase();
+        Integer value = websiteTypeMappings.get(type);
+        return (value == null) ? ContactsContract.CommonDataKinds.Website.TYPE_CUSTOM : value;
+    }
+
+    /**
+     * Maps the value of a X-ABLABEL property to the appropriate
+     * Android {@link ContactsContract.CommonDataKinds.Event} value.
+     * @param type the property value
+     * @return the Android type
+     */
+    public static int getDateType(String type) {
+        if (type == null) {
+            return ContactsContract.CommonDataKinds.Event.TYPE_OTHER;
+        }
+
+        type = type.toLowerCase();
+        for (Map.Entry<String, Integer> entry : abDateMappings.entrySet()){
+            if (type.contains(entry.getKey())){
+                return entry.getValue();
+            }
+        }
+        return ContactsContract.CommonDataKinds.Event.TYPE_OTHER;
+    }
+
+    /**
+     * Maps the value of a X-ABLABEL property to the appropriate
+     * Android {@link ContactsContract.CommonDataKinds.Relation} value.
+     * @param type the property value
+     * @return the Android type
+     */
+    public static int getNameType(String type) {
+        if (type == null) {
+            return ContactsContract.CommonDataKinds.Relation.TYPE_CUSTOM;
+        }
+
+        type = type.toLowerCase();
+        for (Map.Entry<String, Integer> entry : abRelatedNamesMappings.entrySet()){
+            if (type.contains(entry.getKey())){
+                return entry.getValue();
+            }
+        }
+        return ContactsContract.CommonDataKinds.Relation.TYPE_CUSTOM;
+    }
+
+    /**
+     * Gets the mappings that associate an extended property name (e.g. "X-AIM")
+     * with its appropriate Android {@link ContactsContract.CommonDataKinds.Im}
+     * value.
+     * @return the mappings (the key is the property name, the value is the Android value)
+     */
+    public static Map<String, Integer> getImPropertyNameMappings(){
+        return imPropertyNameMappings;
+    }
+
+    /**
+     * Converts an IM protocol from a {@link Impp} property (e.g. "aim") to the
+     * appropriate Android {@link ContactsContract.CommonDataKinds.Im} value.
+     * @param protocol the IM protocol (e.g. "aim", can be null)
+     * @return the Android value
+     */
+    public static int getIMTypeFromProtocol(String protocol) {
+        if (protocol == null){
+            return ContactsContract.CommonDataKinds.Im.PROTOCOL_CUSTOM;
+        }
+
+        protocol = protocol.toLowerCase();
+        Integer value = imProtocolMappings.get(protocol);
+        return (value == null) ? ContactsContract.CommonDataKinds.Im.PROTOCOL_CUSTOM : value;
+    }
+
+    /**
+     * Determines the appropriate Android
+     * {@link ContactsContract.CommonDataKinds.Phone} value for a
+     * {@link Telephone} property.
+     * @param property the property
+     * @return the Android type value
+     */
+    public static int getPhoneType(Telephone property) {
+        for (TelephoneType type : property.getTypes()){
+            Integer androidType = phoneTypeMappings.get(type);
+            if (androidType != null){
+                return androidType;
+            }
+        }
+        return ContactsContract.CommonDataKinds.Phone.TYPE_OTHER;
+    }
+
+    /**
+     * Determines the appropriate Android
+     * {@link ContactsContract.CommonDataKinds.Email} value for an {@link Email}
+     * property.
+     * @param property the property
+     * @return the Android type value
+     */
+    public static int getEmailType(Email property) {
+        for (EmailType type : property.getTypes()){
+            Integer androidType = emailTypeMappings.get(type);
+            if (androidType != null){
+                return androidType;
+            }
+        }
+        return ContactsContract.CommonDataKinds.Email.TYPE_OTHER;
+    }
+
+    /**
+     * Determines the appropriate Android
+     * {@link ContactsContract.CommonDataKinds.StructuredPostal} value for an
+     * {@link Address} property.
+     * @param property the property
+     * @return the Android type value
+     */
+    public static int getAddressType(Address property) {
+        for (AddressType type : property.getTypes()){
+            Integer androidType = addressTypeMappings.get(type);
+            if (androidType != null){
+                return androidType;
+            }
+        }
+        return ContactsContract.CommonDataKinds.StructuredPostal.TYPE_CUSTOM;
+    }
+
+    private DataMappings(){
+        //hide constructor
+    }
+}

src/main/res/layout/contactlist_fragment.xml

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Nextcloud Android client application
+
+  Copyright (C) 2017 Tobias Kaminsky
+  Copyright (C) 2017 Nextcloud.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+  License as published by the Free Software Foundation; either
+  version 3 of the License, or any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU AFFERO GENERAL PUBLIC LICENSE for more details.
+
+  You should have received a copy of the GNU Affero General Public
+  License along with this program. If not, see <http://www.gnu.org/licenses/>.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical">
+
+    <ListView
+        android:id="@+id/contactlist_listview"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_margin="10dp"
+        android:choiceMode="multipleChoice"
+        android:layout_weight="1" />
+
+    <android.support.v7.widget.AppCompatButton
+        android:id="@+id/contactlist_restore_selected"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_margin="10dp"
+        android:enabled="false"
+        android:text="@string/contaclist_restore_selected"
+        android:background="@color/standard_grey"
+        android:theme="@style/Button.Primary"/>
+
+</LinearLayout>

src/main/res/layout/contactlist_list_item.xml

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Nextcloud Android client application
+
+  Copyright (C) 2017 Tobias Kaminsky
+  Copyright (C) 2017 Nextcloud.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+  License as published by the Free Software Foundation; either
+  version 3 of the License, or any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU AFFERO GENERAL PUBLIC LICENSE for more details.
+
+  You should have received a copy of the GNU Affero General Public
+  License along with this program. If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent">
+
+    <QuickContactBadge
+        android:id="@+id/contactlist_item_icon"
+        android:layout_width="?android:attr/listPreferredItemHeight"
+        android:layout_height="?android:attr/listPreferredItemHeight"
+        android:layout_margin="5dp"
+        android:scaleType="centerCrop"
+        android:src="@drawable/ic_user"/>
+
+    <CheckedTextView
+        android:id="@+id/contactlist_item_name"
+        android:layout_width="0dp"
+        android:layout_height="match_parent"
+        android:layout_weight="1"
+        android:checkMark="?android:attr/listChoiceIndicatorMultiple"
+        android:ellipsize="marquee"
+        android:gravity="center_vertical"
+        android:maxLines="1"
+        android:textAppearance="?android:attr/textAppearanceLarge"/>
+
+    <!--<CheckBox-->
+        <!--android:id="@+id/checkBox"-->
+        <!--android:layout_width="wrap_content"-->
+        <!--android:layout_height="match_parent"-->
+        <!--android:padding="10dp"-->
+        <!--/>-->
+
+</LinearLayout>

src/main/res/layout/contacts_preference.xml

@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Nextcloud Android client application
+
+  Copyright (C) 2017 Tobias Kaminsky
+  Copyright (C) 2017 Nextcloud.
+
+  This program is free software; you can redistribute it and/or
+  modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
+  License as published by the Free Software Foundation; either
+  version 3 of the License, or any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+  GNU AFFERO GENERAL PUBLIC LICENSE for more details.
+
+  You should have received a copy of the GNU Affero General Public
+  License along with this program. If not, see <http://www.gnu.org/licenses/>.
+-->
+<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                                        android:id="@+id/drawer_layout"
+                                        android:layout_width="match_parent"
+                                        android:layout_height="match_parent"
+                                        android:clickable="true"
+                                        android:fitsSystemWindows="true">
+
+    <!-- The main content view -->
+    <LinearLayout
+        android:id="@+id/contacts_linear_layout"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical">
+
+        <include
+            layout="@layout/toolbar_standard"/>
+
+        <TextView
+            android:id="@+id/contacts_header_backup"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="10dp"
+            android:layout_marginRight="10dp"
+            android:layout_marginTop="10dp"
+            android:text="@string/contacts_header_backup"
+            android:textColor="@color/primary"/>
+
+        <android.support.v7.widget.SwitchCompat
+            android:id="@+id/contacts_automatic_backup"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_margin="10dp"
+            android:text="@string/contacts_automatic_backup"
+            android:textAppearance="?android:attr/textAppearanceMedium"/>
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <TextView
+                android:id="@+id/contacts_last_backup"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_margin="10dp"
+                android:layout_weight="1"
+                android:text="@string/contacts_last_backup"
+                android:textAppearance="?android:attr/textAppearanceMedium"
+                android:textColor="@color/black"/>
+
+            <TextView
+                android:id="@+id/contacts_last_backup_timestamp"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_margin="10dp"
+                android:layout_weight="1"
+                android:text="2017 / 03 / 10 - 11:33am"
+                android:textAppearance="?android:attr/textAppearanceMedium"/>
+        </LinearLayout>
+
+        <android.support.v7.widget.AppCompatButton
+            android:id="@+id/contacts_backup_now"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_margin="10dp"
+            android:onClick="backupContacts"
+            android:text="@string/contacts_backup_button"
+            android:theme="@style/Button.Primary"/>
+
+        <TextView
+            android:id="@+id/contacts_header_restore"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginLeft="10dp"
+            android:layout_marginRight="10dp"
+            android:layout_marginTop="10dp"
+            android:text="@string/contacts_header_restore"
+            android:textColor="@color/primary"/>
+
+        <android.support.v7.widget.AppCompatButton
+            android:id="@+id/contacts_datepacker"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_margin="10dp"
+            android:onClick="openDate"
+            android:text="@string/contacts_preference_choose_date"
+            android:theme="@style/Button.Primary"/>
+
+    </LinearLayout>
+
+    <include
+        layout="@layout/drawer"
+        android:layout_width="@dimen/drawer_width"
+        android:layout_height="match_parent"
+        android:layout_gravity="start"/>
+
+</android.support.v4.widget.DrawerLayout>

src/main/res/menu/drawer_menu.xml

@@ -109,6 +109,11 @@
     <group
         android:id="@+id/drawer_menu_bottom"
         android:checkableBehavior="single">
+        <item
+            android:id="@+id/nav_contacts"
+            android:icon="@drawable/ic_user"
+            android:orderInCategory="3"
+            android:title="@string/actionbar_contacts"/>
         <item
             android:id="@+id/nav_settings"
             android:icon="@drawable/ic_settings"

src/main/res/values/setup.xml

@@ -37,6 +37,11 @@
     <bool name = "share_via_link_feature">true</bool>
     <bool name = "share_with_users_feature">true</bool>
     <bool name="show_whats_new">true</bool>
+
+    // Contacts backup
+    <bool name="contacts_backup">true</bool>
+    <string name="contacts_backup_folder">/Contacts-Backup</string>
+    <integer name="contacts_backup_expire">-1</integer>
     
     <!-- Colors -->
     <color name="login_text_color">@color/white</color>

src/main/res/values/strings.xml

@@ -620,5 +620,24 @@
     <string name="activities_no_results_headline">No activity yet</string>
     <string name="activities_no_results_message">This stream will show events like\nadditions, changes &amp; shares</string>
 
+    <string name="actionbar_contacts">Contacts backup</string>
+    <string name="contacts_backup_button">Backup now</string>
+    <string name="contacts_restore_button">Restore last backup</string>
+    <string name="contacts_header_restore">Restore</string>
+    <string name="contacts_header_backup">Backup</string>
+    <string name="contacts_automatic_backup">Contacts backup</string>
+    <string name="contacts_last_backup">Last backup</string>
+    <string name="contacts_read_permission">Read permission of contacts is needed</string>
+    <string name="contacts_write_permission">Write permission for contacts is needed</string>
+    <string name="contactlist_title">Restore contacts</string>
+    <string name="contaclist_restore_selected">Restore selected contacts</string>
+    <string name="contactlist_account_chooser_title">Choose account for import</string>
+    <string name="contactlist_no_permission">No permission, nothing imported!</string>
+    <string name="contacts_preference_choose_date">Choose date</string>
+    <string name="contacts_preference_backup_never">never</string>
+    <string name="contacts_preferences_no_file_found">No file found</string>
+    <string name="contacts_preferences_backup_scheduled">Backup scheduled and will start shortly</string>
+    <string name="contacts_preferences_import_scheduled">Import scheduled and will start shortly</string>
+
 
 </resources>

src/modified/res/values/setup.xml

@@ -24,7 +24,7 @@
     <bool name="show_welcome_link">false</bool>
 	<string name="welcome_link_url">"https://nextcloud.com/providers"</string>
 	<string name="share_api_link"></string>
-    
+
     <!-- Flags to setup the authentication methods available in the app -->
     <string name="auth_method_oauth2">off</string>
     <string name="auth_method_saml_web_sso">off</string>
@@ -34,6 +34,11 @@
     <bool name = "share_via_link_feature">true</bool>
     <bool name = "share_with_users_feature">true</bool>
 
+    // Contacts backup
+    <bool name="contacts_backup">true</bool>
+    <string name="contacts_backup_folder">/Contacts-Backup</string>
+    <integer name="contacts_backup_expire">30</integer>
+
     <!-- Colors -->
     <color name="login_text_color">@color/white</color>
     <color name="login_text_hint_color">#7fC0E3</color>