Merge lp:~renatofilho/address-book-service/missing-features into lp:address-book-service

[Renato Araujo Oliveira Filho]

Implemented AddressBook::availableSources.
Implemented support to change sort clause in the view.
Implemented AddressBook::sortFields.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:39
http://jenkins.qa.ubuntu.com/job/address-book-service-ci/22/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-saucy-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-saucy-armhf-ci/22
        deb: http://jenkins.qa.ubuntu.com/job/address-book-service-saucy-armhf-ci/22/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/address-book-service-saucy-i386-ci/22

Click here to trigger a rebuild:
http://s-jenkins:8080/job/address-book-service-ci/22/rebuild

review: Approve (continuous-integration)

[lp:~renatofilho/address-book-service/missing-features]

40. By Renato Araujo Oliveira Filho on 2013-06-20

Merged: lp:~renatofilho/address-book-service/fix-edit

41. By Renato Araujo Oliveira Filho on 2013-06-21

Merged changes from: lp:~renatofilho/address-book-service/fix-edit

Unmerged revisions

=== modified file 'common/sort-clause.cpp'
--- common/sort-clause.cpp	2013-06-11 19:36:01 +0000
+++ common/sort-clause.cpp	2013-06-18 19:48:28 +0000
@@ -94,7 +94,13 @@
     return m_sortOrders;
 }
 
-void SortClause::initialize() const
+QStringList SortClause::supportedFields()
+{
+    initialize();
+    return clauseFieldMap.keys();
+}
+
+void SortClause::initialize()
 {
     if (clauseFieldMap.isEmpty()) {
         clauseFieldMap["NAME_PREFIX"]   = QPair<QContactDetail::DetailType, int>(QContactDetail::TypeName,           QContactName::FieldPrefix);

=== modified file 'common/sort-clause.h'
--- common/sort-clause.h	2013-06-11 13:00:01 +0000
+++ common/sort-clause.h	2013-06-18 19:48:28 +0000
@@ -38,12 +38,14 @@
     QString toString() const;
     QList<QtContacts::QContactSortOrder> toContactSortOrder() const;
 
+    static QStringList supportedFields();
+
 private:
     QList<QtContacts::QContactSortOrder> m_sortOrders;
 
     QtContacts::QContactSortOrder fromString(const QString &clause) const;
     QString toString(const QtContacts::QContactSortOrder &sort) const;
-    void initialize() const;
+    static void initialize();
 };
 
 }

=== modified file 'common/vcard-parser.cpp'
--- common/vcard-parser.cpp	2013-05-18 01:11:38 +0000
+++ common/vcard-parser.cpp	2013-06-18 19:48:28 +0000
@@ -55,7 +55,7 @@
 
             if (detail.type() == QContactDetail::TypeExtendedDetail) {
                 const QContactExtendedDetail *extendedDetail = static_cast<const QContactExtendedDetail *>(&detail);
-                if (extendedDetail->name() == "CLIENTPIDMAP") {
+                if (extendedDetail->name() == galera::VCardParser::PidMapFieldName) {
                     QVersitProperty prop;
                     prop.setName(extendedDetail->name());
                     QStringList value;
@@ -70,11 +70,12 @@
             }
 
             if (!detail.detailUri().isEmpty()) {
-                QVersitProperty prop = toBeAdded->takeLast();
-                QMultiHash<QString, QString> params = prop.parameters();
-                params.insert("PID", detail.detailUri());
-                prop.setParameters(params);
-                *toBeAdded << prop;
+                if (toBeAdded->size() > 0) {
+                    QVersitProperty &prop = toBeAdded->last();
+                    QMultiHash<QString, QString> params = prop.parameters();
+                    params.insert(galera::VCardParser::PidFieldName, detail.detailUri());
+                    prop.setParameters(params);
+                }
             }
         }
 
@@ -102,16 +103,33 @@
             Q_UNUSED(document);
             Q_UNUSED(contact);
 
-            if (!*alreadyProcessed && (property.name() == "CLIENTPIDMAP")) {
+            if (!*alreadyProcessed && (property.name() == galera::VCardParser::PidMapFieldName)) {
                 QContactExtendedDetail detail;
                 detail.setName(property.name());
-                QStringList value = property.value<QStringList>();
+                QStringList value = property.value<QString>().split(";");
                 detail.setValue(QContactExtendedDetail::FieldData, value[0]);
                 detail.setValue(QContactExtendedDetail::FieldData + 1, value[1]);
                 *updatedDetails  << detail;
                 *alreadyProcessed = true;
             }
 
+            QString pid = property.parameters().value(galera::VCardParser::PidFieldName);
+            if (!pid.isEmpty()) {
+                QContactDetail &det = updatedDetails->last();
+                det.setDetailUri(pid);
+            }
+
+            // Remove empty phone subtypes
+            // Remove this after this fix get merged: https://codereview.qt-project.org/#change,59156
+            if (updatedDetails->size() > 0) {
+                QContactDetail &det = updatedDetails->last();
+                if (det.type() == QContactPhoneNumber::Type) {
+                    QContactPhoneNumber phone = static_cast<QContactPhoneNumber>(det);
+                    if (phone.subTypes().size() == 0) {
+                        det.setValue(QContactPhoneNumber::FieldSubTypes, QVariant());
+                    }
+                }
+            }
         }
 
         virtual void documentProcessed(const QVersitDocument& document, QContact* contact)
@@ -125,6 +143,9 @@
 namespace galera
 {
 
+const QString VCardParser::PidMapFieldName = QString("CLIENTPIDMAP");
+const QString VCardParser::PidFieldName = QString("PID");
+
 QStringList VCardParser::contactToVcard(QList<QtContacts::QContact> contacts)
 {
     QStringList result;

=== modified file 'common/vcard-parser.h'
--- common/vcard-parser.h	2013-05-18 01:11:38 +0000
+++ common/vcard-parser.h	2013-06-18 19:48:28 +0000
@@ -29,6 +29,8 @@
 class VCardParser
 {
 public:
+    static const QString PidMapFieldName;
+    static const QString PidFieldName;
 
     static QStringList contactToVcard(QList<QtContacts::QContact> contacts);
     static QtContacts::QContact vcardToContact(const QString &vcard);

=== modified file 'src/addressbook-adaptor.cpp'
--- src/addressbook-adaptor.cpp	2013-06-13 14:00:42 +0000
+++ src/addressbook-adaptor.cpp	2013-06-18 19:48:28 +0000
@@ -36,9 +36,13 @@
     // destructor
 }
 
-SourceList AddressBookAdaptor::availableSources()
+SourceList AddressBookAdaptor::availableSources(const QDBusMessage &message)
 {
-    return m_addressBook->availableSources();
+    message.setDelayedReply(true);
+    QMetaObject::invokeMethod(m_addressBook, "availableSources",
+                              Qt::QueuedConnection,
+                              Q_ARG(const QDBusMessage&, message));
+    return SourceList();
 }
 
 QString AddressBookAdaptor::createContact(const QString &contact, const QString &source, const QDBusMessage &message)

=== modified file 'src/addressbook-adaptor.h'
--- src/addressbook-adaptor.h	2013-06-07 18:54:26 +0000
+++ src/addressbook-adaptor.h	2013-06-18 19:48:28 +0000
@@ -95,14 +95,14 @@
     virtual ~AddressBookAdaptor();
 
 public Q_SLOTS:
-    SourceList availableSources();
+    SourceList availableSources(const QDBusMessage &message);
+    QStringList sortFields();
+    QDBusObjectPath query(const QString &clause, const QString &sort, const QStringList &sources);
+    int removeContacts(const QStringList &contactIds, const QDBusMessage &message);
     QString createContact(const QString &contact, const QString &source, const QDBusMessage &message);
+    QStringList updateContacts(const QStringList &contacts, const QDBusMessage &message);
     QString linkContacts(const QStringList &contacts);
-    QDBusObjectPath query(const QString &clause, const QString &sort, const QStringList &sources);
-    int removeContacts(const QStringList &contactIds, const QDBusMessage &message);
-    QStringList sortFields();
     bool unlinkContacts(const QString &parentId, const QStringList &contactsIds);
-    QStringList updateContacts(const QStringList &contacts, const QDBusMessage &message);
 
 Q_SIGNALS:
     void contactsAdded(const QStringList &ids);

=== modified file 'src/addressbook.cpp'
--- src/addressbook.cpp	2013-06-13 14:35:08 +0000
+++ src/addressbook.cpp	2013-06-18 19:48:28 +0000
@@ -26,7 +26,6 @@
 
 #include <QtCore/QPair>
 #include <QtCore/QUuid>
-#include <QtContacts/QContact>
 
 using namespace QtContacts;
 
@@ -106,12 +105,54 @@
                                         this);
 }
 
-SourceList AddressBook::availableSources()
-{
-    //TODO
-    QList<Source> sources;
-    sources << Source("Facebook", false) << Source("Telepathy", true) << Source("Google", true);
-    return sources;
+SourceList AddressBook::availableSources(const QDBusMessage &message)
+{
+    FolksBackendStore *backendStore = folks_backend_store_dup();
+    QDBusMessage *msg = new QDBusMessage(message);
+
+    if (folks_backend_store_get_is_prepared(backendStore)) {
+        availableSourcesReply(backendStore, 0, msg);
+    } else {
+        folks_backend_store_prepare(backendStore, (GAsyncReadyCallback) availableSourcesReply, msg);
+    }
+    return SourceList();
+}
+
+void AddressBook::availableSourcesReply(FolksBackendStore *backendStore, GAsyncResult *res, QDBusMessage *message)
+{
+    if (res) {
+        folks_backend_store_prepare_finish(backendStore, res);
+    }
+    GeeCollection *backends = folks_backend_store_list_backends(backendStore);
+    SourceList result;
+
+    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(backends));
+    while(gee_iterator_next(iter)) {
+        FolksBackend *backend = FOLKS_BACKEND(gee_iterator_get(iter));
+
+        GeeMap *stores = folks_backend_get_persona_stores(backend);
+        GeeCollection *values =  gee_map_get_values(stores);
+        GeeIterator *backendIter = gee_iterable_iterator(GEE_ITERABLE(values));
+
+        while(gee_iterator_next(backendIter)) {
+            FolksPersonaStore *store = FOLKS_PERSONA_STORE(gee_iterator_get(backendIter));
+
+            QString id = QString::fromUtf8(folks_persona_store_get_id(store));
+            bool canWrite = folks_persona_store_get_is_writeable(store);
+            result << Source(id, !canWrite);
+
+            g_object_unref(store);
+        }
+
+        g_object_unref(backendIter);
+        g_object_unref(backend);
+        g_object_unref(values);
+    }
+    g_object_unref(iter);
+
+    QDBusMessage reply = message->createReply(QVariant::fromValue<SourceList>(result));
+    QDBusConnection::sessionBus().send(reply);
+    delete message;
 }
 
 QString AddressBook::createContact(const QString &contact, const QString &source, const QDBusMessage &message)
@@ -211,10 +252,7 @@
 
 QStringList AddressBook::sortFields()
 {
-    //TODO
-    QStringList fields;
-    fields << "id" << "name" << "full-name";
-    return fields;
+    return SortClause::supportedFields();
 }
 
 bool AddressBook::unlinkContacts(const QString &parent, const QStringList &contacts)
@@ -225,76 +263,74 @@
 
 QStringList AddressBook::updateContacts(const QStringList &contacts, const QDBusMessage &message)
 {
-    UpdateContactsData *data = 0;
-
-    if (!contacts.isEmpty()) {
-        data = new UpdateContactsData;
-        data->m_contacts = VCardParser::vcardToContact(contacts);
-        data->m_request = contacts;
-        data->m_currentIndex = -1;
-        data->m_addressbook = this;
-        data->m_message = message;
-
-    }
-    updateContacts("", data);
+    //TODO: support multiple update contacts calls
+    Q_ASSERT(m_updateCommandPendingContacts.isEmpty());
+
+    m_updateCommandReplyMessage = message;
+    m_updateCommandResult = contacts;
+    m_updateCommandPendingContacts << VCardParser::vcardToContact(contacts);
+
+    updateContactsDone(0, QString());
 
     return QStringList();
 }
 
-void AddressBook::updateContacts(const QString &error, void *userData)
+void AddressBook::updateContactsDone(galera::QIndividual *individual, const QString &error)
 {
-    qDebug() << Q_FUNC_INFO << userData;
-    UpdateContactsData *data = static_cast<UpdateContactsData*>(userData);
-    QDBusMessage reply;
-
-    if (data) {
-        if (!error.isEmpty()) {
-            data->m_result << error;
-        } else if (data->m_currentIndex > -1) {
-            data->m_result << data->m_request[data->m_currentIndex];
-        }
-
-        if (!data->m_contacts.isEmpty()) {
-            QContact newContact = data->m_contacts.takeFirst();
-            data->m_currentIndex++;
-
-            ContactEntry *entry = data->m_addressbook->m_contacts->value(newContact.detail<QContactGuid>().guid());
-            if (entry) {
-                entry->individual()->update(newContact, updateContacts, userData);
-            } else {
-                updateContacts("Contact not found!", userData);
-            }
-            return;
-        }
-        folks_persona_store_flush(folks_individual_aggregator_get_primary_store(data->m_addressbook->m_individualAggregator), 0, 0);
-        reply = data->m_message.createReply(data->m_result);
+    Q_UNUSED(individual);
+    qDebug() << Q_FUNC_INFO;
+
+    if (!error.isEmpty()) {
+        // update the result with the error
+        m_updateCommandResult[m_updateCommandResult.size() - m_updateCommandPendingContacts.size()] = error;
+    }
+
+    if (!m_updateCommandPendingContacts.isEmpty()) {
+        QContact newContact = m_updateCommandPendingContacts.takeFirst();
+        ContactEntry *entry = m_contacts->value(newContact.detail<QContactGuid>().guid());
+        if (entry) {
+            entry->individual()->update(newContact, this, "updateContactsDone(galera::QIndividual*, const QString&)"); //));
+        } else {
+            updateContactsDone(0, "Contact not found!");
+        }
     } else {
-        reply = data->m_message.createReply(QStringList());
+        folks_persona_store_flush(folks_individual_aggregator_get_primary_store(m_individualAggregator), 0, 0);
+        QDBusMessage reply = m_updateCommandReplyMessage.createReply(m_updateCommandResult);
+        QDBusConnection::sessionBus().send(reply);
+
+        // clear command data
+        m_updateCommandResult.clear();
+        m_updateCommandReplyMessage = QDBusMessage();
     }
-
-    QDBusConnection::sessionBus().send(reply);
-    delete data;
 }
 
 
 QString AddressBook::removeContact(FolksIndividual *individual)
 {
-    Q_ASSERT(m_contacts->contains(individual));
-    ContactEntry *ci = m_contacts->take(individual);
-    if (ci) {
-        QString id = QString::fromUtf8(folks_individual_get_id(individual));
-        delete ci;
-        return id;
+    if (m_contacts->contains(individual)) {
+        ContactEntry *ci = m_contacts->take(individual);
+        if (ci) {
+            QString id = QString::fromUtf8(folks_individual_get_id(individual));
+            qDebug() << "Remove contact" << id;
+            delete ci;
+            return id;
+        }
     }
     return QString();
 }
 
 QString AddressBook::addContact(FolksIndividual *individual)
 {
-    Q_ASSERT(!m_contacts->contains(individual));
-    m_contacts->insert(new ContactEntry(new QIndividual(individual, m_individualAggregator)));
-    //TODO: Notify view
-    return QString::fromUtf8(folks_individual_get_id(individual));
+    QString id = QString::fromUtf8(folks_individual_get_id(individual));
+    ContactEntry *entry = m_contacts->value(id);
+    if (entry) {
+        entry->individual()->setIndividual(individual);
+    } else {
+        m_contacts->insert(new ContactEntry(new QIndividual(individual, m_individualAggregator)));
+        qDebug() << "Add contact" << folks_individual_get_id(individual);
+        //TODO: Notify view
+    }
+    return id;
 }
 
 void AddressBook::individualsChangedCb(FolksIndividualAggregator *individualAggregator,
@@ -307,35 +343,34 @@
 
     GeeIterator *iter;
     GeeSet *removed = gee_multi_map_get_keys(changes);
-    iter = gee_iterable_iterator(GEE_ITERABLE(removed));
-
-    while(gee_iterator_next(iter)) {
-        FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
-        if (individual) {
-            QString id = self->removeContact(individual);
-            if(!id.isEmpty()) {
-                removedIds << id;
-            }
-            g_object_unref(individual);
-        }
-    }
-    g_object_unref (iter);
-
     GeeCollection *added = gee_multi_map_get_values(changes);
+
     iter = gee_iterable_iterator(GEE_ITERABLE(added));
     while(gee_iterator_next(iter)) {
         FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
         if (individual) {
-            QString id = self->addContact(individual);
-            if(!id.isEmpty()) {
-                addedIds << id;
+            // add contact to the map
+            addedIds << self->addContact(individual);
+            g_object_unref(individual);
+        }
+    }
+    g_object_unref (iter);
+
+
+    iter = gee_iterable_iterator(GEE_ITERABLE(removed));
+    while(gee_iterator_next(iter)) {
+        FolksIndividual *individual = FOLKS_INDIVIDUAL(gee_iterator_get(iter));
+        if (individual) {
+            QString id = QString::fromUtf8(folks_individual_get_id(individual));
+            if (!addedIds.contains(id)) {
+                // delete from contact map
+                removedIds << self->removeContact(individual);
             }
             g_object_unref(individual);
         }
     }
     g_object_unref (iter);
 
-    //TODO: check for linked and unliked contacts
     if (!removedIds.isEmpty()) {
         Q_EMIT self->m_adaptor->contactsRemoved(removedIds);
     }

=== modified file 'src/addressbook.h'
--- src/addressbook.h	2013-06-13 14:35:08 +0000
+++ src/addressbook.h	2013-06-18 19:48:28 +0000
@@ -28,6 +28,8 @@
 
 #include <QtDBus/QtDBus>
 
+#include <QtContacts/QContact>
+
 #include <folks/folks.h>
 #include <glib.h>
 #include <glib-object.h>
@@ -37,6 +39,7 @@
 class View;
 class ContactsMap;
 class AddressBookAdaptor;
+class QIndividual;
 
 class AddressBook: public QObject
 {
@@ -49,16 +52,17 @@
     bool registerObject(QDBusConnection &connection);
 
     // Adaptor
-    SourceList availableSources();
     QString linkContacts(const QStringList &contacts);
     View *query(const QString &clause, const QString &sort, const QStringList &sources);
     QStringList sortFields();
     bool unlinkContacts(const QString &parent, const QStringList &contacts);
 
 public Q_SLOTS:
+    SourceList availableSources(const QDBusMessage &message);
     QString createContact(const QString &contact, const QString &source, const QDBusMessage &message);
     int removeContacts(const QStringList &contactIds, const QDBusMessage &message);
     QStringList updateContacts(const QStringList &contacts, const QDBusMessage &message);
+    void updateContactsDone(galera::QIndividual *individual, const QString &error);
 
 private Q_SLOTS:
     void viewClosed();
@@ -70,13 +74,18 @@
     bool m_initializing;
     AddressBookAdaptor *m_adaptor;
 
+    // Update command
+    QDBusMessage m_updateCommandReplyMessage;
+    QStringList m_updateCommandResult;
+    QList<QtContacts::QContact> m_updateCommandPendingContacts;
+
     void prepareFolks();
     QString removeContact(FolksIndividual *individual);
     QString addContact(FolksIndividual *individual);
 
-
-    static void updateContacts(const QString &error, void *userData);
-
+    static void availableSourcesReply(FolksBackendStore *backendStore,
+                                      GAsyncResult *res,
+                                      QDBusMessage *message);
     static void individualsChangedCb(FolksIndividualAggregator *individualAggregator,
                                      GeeMultiMap *changes,
                                      AddressBook *self);

=== modified file 'src/contacts-map.cpp'
--- src/contacts-map.cpp	2013-06-11 13:00:01 +0000
+++ src/contacts-map.cpp	2013-06-18 19:48:28 +0000
@@ -28,6 +28,7 @@
 ContactEntry::ContactEntry(QIndividual *individual)
     : m_individual(individual)
 {
+    Q_ASSERT(individual);
 }
 
 ContactEntry::~ContactEntry()
@@ -75,6 +76,16 @@
     return 0;
 }
 
+void ContactsMap::remove(const QString &id)
+{
+    ContactEntry *entry = m_idToEntry[id];
+    if (entry) {
+        m_individualsToEntry.remove(entry->individual()->individual());
+        m_idToEntry.remove(id);
+        delete entry;
+    }
+}
+
 bool ContactsMap::contains(FolksIndividual *individual) const
 {
     return m_individualsToEntry.contains(individual);

=== modified file 'src/contacts-map.h'
--- src/contacts-map.h	2013-06-11 13:00:01 +0000
+++ src/contacts-map.h	2013-06-18 19:48:28 +0000
@@ -60,6 +60,7 @@
     ContactEntry *value(FolksIndividual *individual) const;
     ContactEntry *value(const QString &id) const;
     ContactEntry *take(FolksIndividual *individual);
+    void remove(const QString &id);
     void insert(ContactEntry *entry);
     int size() const;
 

=== modified file 'src/qindividual.cpp'
--- src/qindividual.cpp	2013-06-11 21:49:45 +0000
+++ src/qindividual.cpp	2013-06-18 19:48:28 +0000
@@ -53,14 +53,14 @@
 class UpdateContactData
 {
 public:
-    QContactDetail::DetailType m_currentDetailType;
     QContact m_newContact;
     galera::QIndividual *m_self;
-    FolksPersona *m_persona;
-
-    QList<QContactDetail> m_detailsChanged;
-    galera::UpdateDoneCB m_doneCB;
-    void *m_doneData;
+
+    QList<QContactDetail> m_details;
+    QContactDetail m_currentDetail;
+
+    QObject *m_object;
+    QMetaMethod m_slot;
 };
 
 #ifdef FOLKS_0_9_0
@@ -82,9 +82,6 @@
 namespace galera
 {
 
-// TODO: find a better way to link abstract field with details
-#define FOLKS_DATA_FIELD        10000
-
 #ifdef FOLKS_0_9_0
     #define SET_AFD_NEW() \
         GEE_SET(gee_hash_set_new(FOLKS_TYPE_ABSTRACT_FIELD_DETAILS, \
@@ -96,6 +93,16 @@
                                  NULL, \
                                  NULL))
 
+    #define SET_PERSONA_NEW() \
+        GEE_SET(gee_hash_set_new(FOLKS_TYPE_PERSONA, \
+                                 (GBoxedCopyFunc) g_object_ref, g_object_unref, \
+                                 NULL, \
+                                 NULL, \
+                                 NULL, \
+                                 NULL, \
+                                 NULL, \
+                                 NULL))
+
     #define GEE_MULTI_MAP_AFD_NEW(FOLKS_TYPE) \
         GEE_MULTI_MAP(gee_hash_multi_map_new(G_TYPE_STRING,\
                                              (GBoxedCopyFunc) g_strdup, g_free, \
@@ -120,6 +127,13 @@
                                  (GHashFunc) folks_abstract_field_details_hash, \
                                  (GEqualFunc) folks_abstract_field_details_equal))
 
+    #define SET_PERSONA_NEW() \
+        GEE_SET(gee_hash_set_new(FOLKS_TYPE_PERSONA, \
+                             (GBoxedCopyFunc) g_object_ref, g_object_unref, \
+                             NULL, \
+                             NULL))
+
+
     #define GEE_MULTI_MAP_AFD_NEW(FOLKS_TYPE) \
         GEE_MULTI_MAP(gee_hash_multi_map_new(G_TYPE_STRING, \
                                              (GBoxedCopyFunc) g_strdup, \
@@ -131,16 +145,17 @@
                                               (GHashFunc) folks_abstract_field_details_hash, \
                                               (GEqualFunc) folks_abstract_field_details_equal));
 
+
+
 #endif
 
 
 #define PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(\
-        details, key, value, q_type, g_type, member) \
+        details, cDetails, key, value, q_type, g_type, member) \
 { \
-    QList<q_type> contactDetails = contact.details<q_type>(); \
-    if(contactDetails.size() > 0) { \
+    if(cDetails.size() > 0) { \
         value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT); \
-        Q_FOREACH(const q_type& detail, contact.details<q_type>()) { \
+        Q_FOREACH(const q_type& detail, cDetails) { \
             if(!detail.isEmpty()) { \
                 QIndividualUtils::gValueGeeSetAddStringFieldDetails(value, (g_type), \
                         detail.member().toUtf8().data(), \
@@ -242,10 +257,53 @@
         return retval;
     }
 
+    static FolksAbstractFieldDetails *getDetails(GeeSet *set, const QString &uri)
+    {
+        Q_ASSERT(set);
+
+        int pos = 0;
+        int size = 0;
+        QStringList index = uri.split(".");
+        gpointer* values = gee_collection_to_array(GEE_COLLECTION(set), &size);
+
+        if (size == 0) {
+            return 0;
+        } else if (index.count() == 2) {
+            pos = index[1].toInt() - 1;
+            Q_ASSERT(pos >= 0);
+            Q_ASSERT(pos < size);
+        }
+        return FOLKS_ABSTRACT_FIELD_DETAILS(values[pos]);
+    }
+
+    static FolksPersona *personaFromUri(const QString &uri, FolksIndividual *individual, FolksPersona *defaultPersona)
+    {
+        Q_ASSERT(individual);
+
+        if (uri.isEmpty()) {
+            //TODO
+            qWarning() << "NO PERSONA";
+            return defaultPersona;
+        } else {
+
+            GeeSet *personas = folks_individual_get_personas(individual);
+            QStringList index = uri.split(".");
+            Q_ASSERT(index.count() >= 1);
+            int pos = index[0].toInt() - 1;
+            int size = 0;
+            gpointer* values = gee_collection_to_array(GEE_COLLECTION(personas), &size);
+            Q_ASSERT(pos >= 0);
+            Q_ASSERT(pos < size);
+
+            return FOLKS_PERSONA(values[pos]);
+        }
+    }
+
 }; // class
 
 QIndividual::QIndividual(FolksIndividual *individual, FolksIndividualAggregator *aggregator)
     : m_individual(individual),
+      m_primaryPersona(0),
       m_aggregator(aggregator)
 {
     g_object_ref(m_individual);
@@ -267,7 +325,6 @@
 QList<QtContacts::QContactDetail> QIndividual::getClientPidMap() const
 {
     QList<QtContacts::QContactDetail> details;
-    /*
     int index = 1;
     GeeSet *personas = folks_individual_get_personas(m_individual);
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
@@ -282,16 +339,75 @@
     }
 
     g_object_unref(iter);
-    */
-    return details;
-}
-
-
-QtContacts::QContactDetail QIndividual::getName() const
-{
+    return details;
+}
+
+void QIndividual::appendDetailsForPersona(QList<QtContacts::QContactDetail> *list, QtContacts::QContactDetail detail, const QString &personaIndex, bool readOnly) const
+{
+    if (!detail.isEmpty()) {
+        detail.setDetailUri(personaIndex);
+        if (readOnly) {
+            QContactManagerEngine::setDetailAccessConstraints(&detail, QContactDetail::ReadOnly);
+        }
+        list->append(detail);
+    }
+}
+
+void QIndividual::appendDetailsForPersona(QList<QtContacts::QContactDetail> *list, QList<QtContacts::QContactDetail> details, const QString &personaIndex, bool readOnly) const
+{
+    int subIndex = 1;
+    Q_FOREACH(QContactDetail detail, details) {
+        appendDetailsForPersona(list, detail, QString("%1.%2").arg(personaIndex).arg(subIndex), readOnly);
+        subIndex++;
+    }
+}
+
+
+QList<QContactDetail> QIndividual::getDetails() const
+{
+    int personaIndex = 1;
+    QList<QContactDetail> details;
+    GeeSet *personas = folks_individual_get_personas(m_individual);
+    GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
+
+    while(gee_iterator_next(iter)) {
+        FolksPersona *persona = FOLKS_PERSONA(gee_iterator_get(iter));
+
+        int wsize = 0;
+        gchar **wproperties = folks_persona_get_writeable_properties(persona, &wsize);
+        //"gender", "local-ids", "avatar", "postal-addresses", "urls", "phone-numbers", "structured-name",
+        //"anti-links", "im-addresses", "is-favourite", "birthday", "notes", "roles", "email-addresses",
+        //"web-service-addresses", "groups", "full-name"
+        QStringList wPropList;
+        for(int i=0; i < wsize; i++) {
+            wPropList << wproperties[i];
+        }
+
+        QString index = QString::number(personaIndex);
+
+        appendDetailsForPersona(&details, getPersonaName(persona), index, !wPropList.contains("structured-name"));
+        appendDetailsForPersona(&details, getPersonaFullName(persona), index, !wPropList.contains("full-name"));
+        appendDetailsForPersona(&details, getPersonaNickName(persona), index, !wPropList.contains("nickname"));
+        appendDetailsForPersona(&details, getPersonaBirthday(persona), index, !wPropList.contains("birthday"));
+        appendDetailsForPersona(&details, getPersonaRoles(persona), index, !wPropList.contains("roles"));
+        appendDetailsForPersona(&details, getPersonaEmails(persona), index, !wPropList.contains("email-addresses"));
+        appendDetailsForPersona(&details, getPersonaPhones(persona), index, !wPropList.contains("phone-numbers"));
+        appendDetailsForPersona(&details, getPersonaAddresses(persona), index, !wPropList.contains("postal-addresses"));
+        appendDetailsForPersona(&details, getPersonaIms(persona), index, !wPropList.contains("im-addresses"));
+        appendDetailsForPersona(&details, getPersonaUrls(persona), index, !wPropList.contains("urls"));
+        personaIndex++;
+    }
+    return details;
+}
+
+QContactDetail QIndividual::getPersonaName(FolksPersona *persona) const
+{
+    if (!FOLKS_IS_NAME_DETAILS(persona)) {
+        return QContactDetail();
+    }
+
     QContactName detail;
-    FolksStructuredName *sn = folks_name_details_get_structured_name(FOLKS_NAME_DETAILS(m_individual));
-
+    FolksStructuredName *sn = folks_name_details_get_structured_name(FOLKS_NAME_DETAILS(persona));
     if (sn) {
         const char *name = folks_structured_name_get_given_name(sn);
         if (name && strlen(name)) {
@@ -317,30 +433,42 @@
     return detail;
 }
 
-QtContacts::QContactDetail QIndividual::getFullName() const
+QtContacts::QContactDetail QIndividual::getPersonaFullName(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_NAME_DETAILS(persona)) {
+        return QContactDetail();
+    }
+
     QContactDisplayLabel detail;
-    const gchar *fullName = folks_name_details_get_full_name(FOLKS_NAME_DETAILS(m_individual));
+    const gchar *fullName = folks_name_details_get_full_name(FOLKS_NAME_DETAILS(persona));
     if (fullName && strlen(fullName)) {
         detail.setLabel(QString::fromUtf8(fullName));
     }
     return detail;
 }
 
-QtContacts::QContactDetail QIndividual::getNickname() const
+QtContacts::QContactDetail QIndividual::getPersonaNickName(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_NAME_DETAILS(persona)) {
+        return QContactDetail();
+    }
+
     QContactNickname detail;
-    const gchar* nickname = folks_name_details_get_nickname(FOLKS_NAME_DETAILS(m_individual));
+    const gchar* nickname = folks_name_details_get_nickname(FOLKS_NAME_DETAILS(persona));
     if (nickname && strlen(nickname)) {
         detail.setNickname(QString::fromUtf8(nickname));
     }
     return detail;
 }
 
-QtContacts::QContactDetail QIndividual::getBirthday() const
+QtContacts::QContactDetail QIndividual::getPersonaBirthday(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_BIRTHDAY_DETAILS(persona)) {
+        return QContactDetail();
+    }
+
     QContactBirthday detail;
-    GDateTime* datetime = folks_birthday_details_get_birthday(FOLKS_BIRTHDAY_DETAILS(m_individual));
+    GDateTime* datetime = folks_birthday_details_get_birthday(FOLKS_BIRTHDAY_DETAILS(persona));
     if (datetime) {
         QDate date(g_date_time_get_year(datetime), g_date_time_get_month(datetime), g_date_time_get_day_of_month(datetime));
         QTime time(g_date_time_get_hour(datetime), g_date_time_get_minute(datetime), g_date_time_get_second(datetime));
@@ -349,16 +477,20 @@
     return detail;
 }
 
-QtContacts::QContactDetail QIndividual::getPhoto() const
+QtContacts::QContactDetail QIndividual::getPersonaPhoto(FolksPersona *persona) const
 {
     // TODO
     return QContactAvatar();
 }
 
-QList<QtContacts::QContactDetail> QIndividual::getRoles() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaRoles(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_ROLE_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
+
     QList<QtContacts::QContactDetail> details;
-    GeeSet *roles = folks_role_details_get_roles(FOLKS_ROLE_DETAILS(m_individual));
+    GeeSet *roles = folks_role_details_get_roles(FOLKS_ROLE_DETAILS(persona));
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(roles));
 
     while(gee_iterator_next(iter)) {
@@ -379,10 +511,14 @@
     return details;
 }
 
-QList<QtContacts::QContactDetail> QIndividual::getEmails() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaEmails(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_EMAIL_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
+
     QList<QtContacts::QContactDetail> details;
-    GeeSet *emails = folks_email_details_get_email_addresses(FOLKS_EMAIL_DETAILS(m_individual));
+    GeeSet *emails = folks_email_details_get_email_addresses(FOLKS_EMAIL_DETAILS(persona));
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(emails));
 
     while(gee_iterator_next(iter)) {
@@ -402,10 +538,14 @@
     return details;
 }
 
-QList<QtContacts::QContactDetail> QIndividual::getPhones() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaPhones(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_PHONE_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
+
     QList<QtContacts::QContactDetail> details;
-    GeeSet *phones = folks_phone_details_get_phone_numbers(FOLKS_PHONE_DETAILS(m_individual));
+    GeeSet *phones = folks_phone_details_get_phone_numbers(FOLKS_PHONE_DETAILS(persona));
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(phones));
 
     while(gee_iterator_next(iter)) {
@@ -425,10 +565,14 @@
     return details;
 }
 
-QList<QtContacts::QContactDetail> QIndividual::getAddresses() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaAddresses(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_POSTAL_ADDRESS_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
+
     QList<QtContacts::QContactDetail> details;
-    GeeSet *addresses = folks_postal_address_details_get_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(m_individual));
+    GeeSet *addresses = folks_postal_address_details_get_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(persona));
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(addresses));
 
     while(gee_iterator_next(iter)) {
@@ -476,10 +620,14 @@
     return details;
 }
 
-QList<QtContacts::QContactDetail> QIndividual::getIms() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaIms(FolksPersona *persona) const
 {
+    if (!FOLKS_IS_IM_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
+
     QList<QtContacts::QContactDetail> details;
-    GeeMultiMap *ims = folks_im_details_get_im_addresses(FOLKS_IM_DETAILS(m_individual));
+    GeeMultiMap *ims = folks_im_details_get_im_addresses(FOLKS_IM_DETAILS(persona));
     GeeSet *keys = gee_multi_map_get_keys(ims);
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(keys));
 
@@ -508,16 +656,14 @@
     return details;
 }
 
-QtContacts::QContactDetail QIndividual::getTimeZone() const
+QList<QtContacts::QContactDetail> QIndividual::getPersonaUrls(FolksPersona *persona) const
 {
-    //TODO
-    return QContactDetail();
-}
+    if (!FOLKS_IS_URL_DETAILS(persona)) {
+        return QList<QtContacts::QContactDetail>();
+    }
 
-QList<QtContacts::QContactDetail> QIndividual::getUrls() const
-{
     QList<QtContacts::QContactDetail> details;
-    GeeSet *urls = folks_url_details_get_urls(FOLKS_URL_DETAILS(m_individual));
+    GeeSet *urls = folks_url_details_get_urls(FOLKS_URL_DETAILS(persona));
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(urls));
 
     while(gee_iterator_next(iter)) {
@@ -635,519 +781,662 @@
 {
     m_contact = QContact();
     m_contact.appendDetail(getUid());
-    m_contact.appendDetail(getName());
-    m_contact.appendDetail(getFullName());
-    m_contact.appendDetail(getNickname());
-    m_contact.appendDetail(getBirthday());
-    m_contact.appendDetail(getPhoto());
-    m_contact.appendDetail(getTimeZone());
     Q_FOREACH(QContactDetail detail, getClientPidMap()) {
         m_contact.appendDetail(detail);
     }
-    Q_FOREACH(QContactDetail detail, getRoles()) {
-        m_contact.appendDetail(detail);
-    }
-    Q_FOREACH(QContactDetail detail, getEmails()) {
-        m_contact.appendDetail(detail);
-    }
-    Q_FOREACH(QContactDetail detail, getPhones()) {
-        m_contact.appendDetail(detail);
-    }
-    Q_FOREACH(QContactDetail detail, getAddresses()) {
-        m_contact.appendDetail(detail);
-    }
-    Q_FOREACH(QContactDetail detail, getIms()) {
-        m_contact.appendDetail(detail);
-    }
-    Q_FOREACH(QContactDetail detail, getUrls()) {
-        m_contact.appendDetail(detail);
-    }
+
+    Q_FOREACH(QContactDetail detail, getDetails()) {
+        m_contact.appendDetail(detail);
+    }
+}
+
+void QIndividual::createPersonaForDetail(QList<QtContacts::QContactDetail> cDetails, ParseDetailsFunc parseFunc, void *data) const
+{
+    GHashTable *details = g_hash_table_new_full(g_str_hash,
+                                                g_str_equal,
+                                                NULL,
+                                                (GDestroyNotify) QIndividualUtils::gValueSliceFree);
+
+    parseFunc(details, cDetails);
+
+    folks_individual_aggregator_add_persona_from_details(m_aggregator,
+                                                         NULL, // we should pass the m_individual here but due a bug on folks lest do a work around
+                                                         folks_individual_aggregator_get_primary_store(m_aggregator),
+                                                         details,
+                                                         (GAsyncReadyCallback) createPersonaDone,
+                                                         (void*) data);
+
+    g_hash_table_destroy(details);
 }
 
 void QIndividual::updateFullName(const QtContacts::QContactDetail &detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QContactDetail originalLabel = m_contact.detail(QContactDetail::TypeDisplayLabel);
-    if (FOLKS_IS_NAME_DETAILS(udata->m_persona) && (originalLabel != detail)) {
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalLabel = detailFromUri(QContactDetail::TypeDisplayLabel, detail.detailUri());
+
+    if (persona == 0) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseFullNameDetails, data);
+    } else if (FOLKS_IS_NAME_DETAILS(persona) && (originalLabel != detail)) {
         const QContactDisplayLabel *label = static_cast<const QContactDisplayLabel*>(&detail);
 
-        folks_name_details_change_full_name(FOLKS_NAME_DETAILS(udata->m_persona),
+        folks_name_details_change_full_name(FOLKS_NAME_DETAILS(persona),
                                             label->label().toUtf8().data(),
                                             (GAsyncReadyCallback) updateDetailsDone,
                                             data);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
 void QIndividual::updateName(const QtContacts::QContactDetail &detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QContactDetail originalName = m_contact.detail(QContactDetail::TypeName);
-    if (FOLKS_IS_NAME_DETAILS(udata->m_persona) && (originalName != detail)) {
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalName = detailFromUri(QContactDetail::TypeName, detail.detailUri());
+
+    if (persona == 0) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseNameDetails, data);
+    } else if (FOLKS_IS_NAME_DETAILS(persona) && (originalName != detail)) {
         const QContactName *name = static_cast<const QContactName*>(&detail);
-        FolksStructuredName *sn = folks_name_details_get_structured_name(FOLKS_NAME_DETAILS(m_individual));
-        if (!sn) {
-            sn = folks_structured_name_new(name->lastName().toUtf8().data(),
-                                           name->firstName().toUtf8().data(),
-                                           name->middleName().toUtf8().data(),
-                                           name->prefix().toUtf8().data(),
-                                           name->suffix().toUtf8().data());
-        } else {
-            folks_structured_name_set_family_name(sn, name->lastName().toUtf8().data());
-            folks_structured_name_set_given_name(sn, name->firstName().toUtf8().data());
-            folks_structured_name_set_additional_names(sn, name->middleName().toUtf8().data());
-            folks_structured_name_set_prefixes(sn, name->prefix().toUtf8().data());
-            folks_structured_name_set_suffixes(sn, name->suffix().toUtf8().data());
-        }
+        FolksStructuredName *sn;
+        sn = folks_structured_name_new(name->lastName().toUtf8().data(),
+                                       name->firstName().toUtf8().data(),
+                                       name->middleName().toUtf8().data(),
+                                       name->prefix().toUtf8().data(),
+                                       name->suffix().toUtf8().data());
 
-        folks_name_details_change_structured_name(FOLKS_NAME_DETAILS(udata->m_persona),
+        folks_name_details_change_structured_name(FOLKS_NAME_DETAILS(persona),
                                                   sn,
                                                   (GAsyncReadyCallback) updateDetailsDone,
                                                   data);
+
         g_object_unref(sn);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
 void QIndividual::updateNickname(const QtContacts::QContactDetail &detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QContactDetail originalNickname = m_contact.detail(QContactDetail::TypeNickname);
-    if (FOLKS_IS_NAME_DETAILS(udata->m_persona) && (originalNickname != detail)) {
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalNickname = detailFromUri(QContactDetail::TypeNickname, detail.detailUri());
+
+    if (persona == 0) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseNicknameDetails, data);
+    } else if (FOLKS_IS_NAME_DETAILS(persona) && (originalNickname != detail)) {
         const QContactNickname *nickname = static_cast<const QContactNickname*>(&detail);
-        folks_name_details_change_nickname(FOLKS_NAME_DETAILS(udata->m_persona),
+        folks_name_details_change_nickname(FOLKS_NAME_DETAILS(persona),
                                            nickname->nickname().toUtf8().data(),
                                            (GAsyncReadyCallback) updateDetailsDone,
                                            data);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
 void QIndividual::updateBirthday(const QtContacts::QContactDetail &detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QContactDetail originalBirthday = m_contact.detail(QContactDetail::TypeBirthday);
-    if (FOLKS_IS_BIRTHDAY_DETAILS(udata->m_persona) && (originalBirthday != detail)) {
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalBirthday = detailFromUri(QContactDetail::TypeBirthday, detail.detailUri());
+
+    if (persona == 0) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseBirthdayDetails, data);
+    } else if (FOLKS_IS_BIRTHDAY_DETAILS(persona) && (originalBirthday != detail)) {
         const QContactBirthday *birthday = static_cast<const QContactBirthday*>(&detail);
+
         GDateTime *dateTime = NULL;
         if (!birthday->isEmpty()) {
             dateTime = g_date_time_new_from_unix_utc(birthday->dateTime().toMSecsSinceEpoch() / 1000);
         }
-        folks_birthday_details_change_birthday(FOLKS_BIRTHDAY_DETAILS(udata->m_persona),
+        folks_birthday_details_change_birthday(FOLKS_BIRTHDAY_DETAILS(persona),
                                                dateTime,
                                                (GAsyncReadyCallback) updateDetailsDone,
                                                data);
         g_date_time_unref(dateTime);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
 void QIndividual::updatePhoto(const QtContacts::QContactDetail &detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QContactDetail originalAvatar = m_contact.detail(QContactDetail::TypeAvatar);
-    if (FOLKS_IS_AVATAR_DETAILS(udata->m_persona) && (detail != originalAvatar)) {
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalAvatar = detailFromUri(QContactDetail::TypeAvatar, detail.detailUri());
+
+    if (persona == 0) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parsePhotoDetails, data);
+    } else if (FOLKS_IS_AVATAR_DETAILS(persona) && (detail != originalAvatar)) {
         //TODO:
         //const QContactAvatar *avatar = static_cast<const QContactAvatar*>(&detail);
-        folks_avatar_details_change_avatar(FOLKS_AVATAR_DETAILS(udata->m_persona),
+        folks_avatar_details_change_avatar(FOLKS_AVATAR_DETAILS(persona),
                                            0,
                                            (GAsyncReadyCallback) updateDetailsDone,
                                            data);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updateTimezone(const QtContacts::QContactDetail &detail, void* data)
-{
-    //TODO
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
-}
-
-void QIndividual::updateRoles(QList<QtContacts::QContactDetail> details, void* data)
-{
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalOrganizations = m_contact.details(QContactDetail::TypeOrganization);
-
-    if (FOLKS_IS_ROLE_DETAILS(udata->m_persona) && !detailListIsEqual(originalOrganizations, details)) {
-        GeeSet *roleSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactOrganization *org = static_cast<const QContactOrganization*>(&detail);
-
-            // The role values can not be NULL
-            const gchar* title = org->title().toUtf8().data();
-            const gchar* name = org->name().toUtf8().data();
-            const gchar* roleName = org->role().toUtf8().data();
-
-            FolksRole *role = folks_role_new(title ? title : "", name ? name : "", "");
-            folks_role_set_role(role, roleName ? roleName : "");
-
-            FolksRoleFieldDetails *fieldDetails = folks_role_field_details_new(role, NULL);
-            parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(fieldDetails), detail);
-            gee_collection_add(GEE_COLLECTION(roleSet), fieldDetails);
-
-            g_object_unref(role);
-            g_object_unref(fieldDetails);
-        }
-
-        folks_role_details_change_roles(FOLKS_ROLE_DETAILS(udata->m_persona),
+void QIndividual::updateRole(QtContacts::QContactDetail detail, void* data)
+{
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalRole = detailFromUri(QContactDetail::TypeOrganization, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseOrganizationDetails, data);
+    } else if (FOLKS_IS_ROLE_DETAILS(persona) && (originalRole != detail)) {
+        FolksRoleFieldDetails *roleDetails = 0;
+        const QContactOrganization *cRole = static_cast<const QContactOrganization*>(&detail);
+        GeeSet *roleSet = folks_role_details_get_roles(FOLKS_ROLE_DETAILS(persona));
+
+        if (!roleSet || (gee_collection_get_size(GEE_COLLECTION(roleSet)) == 0)) {
+            roleSet = SET_AFD_NEW();
+        } else {
+            roleDetails = FOLKS_ROLE_FIELD_DETAILS(QIndividualUtils::getDetails(roleSet, detail.detailUri()));
+            // this will be unref at the end of the function
+            g_object_ref(roleSet);
+            g_object_ref(roleDetails);
+        }
+
+        const gchar* title = cRole->title().isEmpty() ? "" : cRole->title().toUtf8().data();
+        const gchar* name = cRole->name().isEmpty() ? "" : cRole->name().toUtf8().data();
+        const gchar* roleName = cRole->role().isEmpty() ? "" : cRole->role().toUtf8().data();
+
+        FolksRole *roleValue;
+        if (!roleDetails) {
+            roleValue = folks_role_new(title, name, "");
+            folks_role_set_role(roleValue, roleName);
+
+            roleDetails = folks_role_field_details_new(roleValue, NULL);
+            gee_collection_add(GEE_COLLECTION(roleSet), roleDetails);
+        } else {
+            roleValue = FOLKS_ROLE(folks_abstract_field_details_get_value(FOLKS_ABSTRACT_FIELD_DETAILS(roleDetails)));
+            folks_role_set_organisation_name(roleValue, name);
+            folks_role_set_title(roleValue, title);
+            folks_role_set_role(roleValue, roleName);
+        }
+
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(roleDetails), detail);
+        folks_role_details_change_roles(FOLKS_ROLE_DETAILS(persona),
                                         roleSet,
                                         (GAsyncReadyCallback) updateDetailsDone,
                                         data);
+
+        g_object_unref(roleDetails);
         g_object_unref(roleSet);
+        g_object_unref(roleValue);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updateEmails(QList<QtContacts::QContactDetail> details, void* data)
+void QIndividual::updateEmail(QtContacts::QContactDetail detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalEmails = m_contact.details(QContactDetail::TypeEmailAddress);
-
-    if (FOLKS_IS_EMAIL_DETAILS(udata->m_persona) && !detailListIsEqual(originalEmails, details)) {
-        GeeSet *emailSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactEmailAddress *email = static_cast<const QContactEmailAddress*>(&detail);
-
-            if(!email->isEmpty()) {
-                FolksEmailFieldDetails *emailDetails = folks_email_field_details_new(email->emailAddress().toUtf8().data(), NULL);
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(emailDetails), detail);
-                gee_collection_add(GEE_COLLECTION(emailSet), emailDetails);
-                g_object_unref(emailDetails);
-            }
-        }
-        folks_email_details_change_email_addresses(FOLKS_EMAIL_DETAILS(udata->m_persona),
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalEmail = detailFromUri(QContactDetail::TypeEmailAddress, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseEmailDetails, data);
+    } else if (FOLKS_IS_EMAIL_DETAILS(persona) && (originalEmail != detail)) {
+        FolksEmailFieldDetails *emailDetails = 0;
+        const QContactEmailAddress *email = static_cast<const QContactEmailAddress*>(&detail);
+        GeeSet *emailSet = folks_email_details_get_email_addresses(FOLKS_EMAIL_DETAILS(persona));
+        if (!emailSet || (gee_collection_get_size(GEE_COLLECTION(emailSet)) == 0)) {
+            emailSet = SET_AFD_NEW();
+        } else {
+            emailDetails = FOLKS_EMAIL_FIELD_DETAILS(QIndividualUtils::getDetails(emailSet, detail.detailUri()));
+            // this will be unref at the end of the function
+            g_object_ref(emailSet);
+            g_object_ref(emailDetails);
+        }
+
+        if (!emailDetails) {
+            emailDetails = folks_email_field_details_new(email->emailAddress().toUtf8().data(), NULL);
+            gee_collection_add(GEE_COLLECTION(emailSet), emailDetails);
+        } else {
+            folks_abstract_field_details_set_value(FOLKS_ABSTRACT_FIELD_DETAILS(emailDetails),
+                                                   email->emailAddress().toUtf8().data());
+        }
+
+        folks_email_details_change_email_addresses(FOLKS_EMAIL_DETAILS(persona),
                                                    emailSet,
                                                    (GAsyncReadyCallback) updateDetailsDone,
                                                    data);
+
         g_object_unref(emailSet);
+        g_object_unref(emailDetails);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updatePhones(QList<QtContacts::QContactDetail> details, void* data)
+void QIndividual::updatePhone(QtContacts::QContactDetail detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalPhones = m_contact.details(QContactDetail::TypePhoneNumber);
-
-    if (FOLKS_IS_PHONE_DETAILS(udata->m_persona) && !detailListIsEqual(originalPhones, details)) {
-        GeeSet *phoneSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactPhoneNumber *phone = static_cast<const QContactPhoneNumber*>(&detail);
-
-            if(!phone->isEmpty()) {
-                FolksPhoneFieldDetails *phoneDetails = folks_phone_field_details_new(phone->number().toUtf8().data(), NULL);
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(phoneDetails), detail);
-                gee_collection_add(GEE_COLLECTION(phoneSet), phoneDetails);
-                g_object_unref(phoneDetails);
-            }
-        }
-        folks_phone_details_change_phone_numbers(FOLKS_PHONE_DETAILS(udata->m_persona),
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalPhone = detailFromUri(QContactDetail::TypePhoneNumber, detail.detailUri());
+    // if we do not have a persona for this detail we need to create one
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parsePhoneNumbersDetails, data);
+    } else if (FOLKS_IS_PHONE_DETAILS(persona) && (originalPhone != detail)) {
+        /// Only update the details on the current persona
+        FolksPhoneFieldDetails *phoneDetails = 0;
+        const QContactPhoneNumber *phone = static_cast<const QContactPhoneNumber*>(&detail);
+        GeeSet *phoneSet = folks_phone_details_get_phone_numbers(FOLKS_PHONE_DETAILS(persona));
+
+        if (!phoneSet || (gee_collection_get_size(GEE_COLLECTION(phoneSet)) == 0)) {
+            phoneSet = SET_AFD_NEW();
+        } else {
+            phoneDetails = FOLKS_PHONE_FIELD_DETAILS(QIndividualUtils::getDetails(phoneSet, detail.detailUri()));
+            // this will be unref at the end of the function
+            g_object_ref(phoneSet);
+            g_object_ref(phoneDetails);
+        }
+
+        if (!phoneDetails) {
+            phoneDetails = folks_phone_field_details_new(phone->number().toUtf8().data(), NULL);
+            gee_collection_add(GEE_COLLECTION(phoneSet), phoneDetails);
+        } else {
+            folks_abstract_field_details_set_value(FOLKS_ABSTRACT_FIELD_DETAILS(phoneDetails),
+                                                   phone->number().toUtf8().data());
+        }
+
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(phoneDetails), detail);
+        folks_phone_details_change_phone_numbers(FOLKS_PHONE_DETAILS(persona),
                                                  phoneSet,
                                                  (GAsyncReadyCallback) updateDetailsDone,
                                                  data);
+        g_object_unref(phoneDetails);
         g_object_unref(phoneSet);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
-    }
-}
-
-bool QIndividual::detailListIsEqual(QList<QtContacts::QContactDetail> original, QList<QtContacts::QContactDetail> details)
-{
-    if (original.size() != details.size()) {
-        return false;
-    }
-
-    Q_FOREACH(const QContactDetail& detail, details) {
-        if (!original.contains(detail)) {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-void QIndividual::updateAddresses(QList<QtContacts::QContactDetail> details, void* data)
-{
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalAddress = m_contact.details(QContactDetail::TypeAddress);
-
-    if (FOLKS_IS_POSTAL_ADDRESS_DETAILS(udata->m_persona) && !detailListIsEqual(originalAddress, details)) {
-        GeeSet *addressSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactAddress *address = static_cast<const QContactAddress*>(&detail);
-            if (!address->isEmpty()) {
-                FolksPostalAddress *postalAddress = folks_postal_address_new(address->postOfficeBox().toUtf8().data(),
-                                                                             NULL,
-                                                                             address->street().toUtf8().data(),
-                                                                             address->locality().toUtf8().data(),
-                                                                             address->region().toUtf8().data(),
-                                                                             address->postcode().toUtf8().data(),
-                                                                             address->country().toUtf8().data(),
-                                                                             NULL,
-                                                                             NULL);
-                FolksPostalAddressFieldDetails *pafd = folks_postal_address_field_details_new(postalAddress, NULL);
-
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(pafd), detail);
-                gee_collection_add(GEE_COLLECTION(addressSet), pafd);
-
-                g_object_unref(postalAddress);
-                g_object_unref(pafd);
-            }
-        }
-
-        folks_postal_address_details_change_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(udata->m_persona),
-                                                             addressSet,
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
+    }
+}
+
+void QIndividual::updateAddress(QtContacts::QContactDetail detail, void* data)
+{
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalAddress = detailFromUri(QContactDetail::TypeAddress, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseAddressDetails, data);
+    } else if (FOLKS_IS_POSTAL_ADDRESS_DETAILS(persona) && (originalAddress != detail)) {
+        FolksPostalAddressFieldDetails *addrDetails = 0;
+        const QContactAddress *addr = static_cast<const QContactAddress*>(&detail);
+        GeeSet *addrSet = folks_postal_address_details_get_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(persona));
+
+        if (!addrSet || (gee_collection_get_size(GEE_COLLECTION(addrSet)) == 0)) {
+            addrSet = SET_AFD_NEW();
+        } else {
+            addrDetails = FOLKS_POSTAL_ADDRESS_FIELD_DETAILS(QIndividualUtils::getDetails(addrSet, detail.detailUri()));
+            // this will be unref at the end of the function
+            g_object_ref(addrSet);
+            g_object_ref(addrDetails);
+        }
+
+        FolksPostalAddress *addrValue;
+        if (!addrDetails) {
+            addrValue = folks_postal_address_new(addr->postOfficeBox().toUtf8().data(),
+                                                   NULL,
+                                                   addr->street().toUtf8().data(),
+                                                   addr->locality().toUtf8().data(),
+                                                   addr->region().toUtf8().data(),
+                                                   addr->postcode().toUtf8().data(),
+                                                   addr->country().toUtf8().data(),
+                                                   NULL,
+                                                   NULL);
+            addrDetails = folks_postal_address_field_details_new(addrValue, NULL);
+            gee_collection_add(GEE_COLLECTION(addrSet), addrDetails);
+        } else {
+            addrValue = FOLKS_POSTAL_ADDRESS(folks_abstract_field_details_get_value(FOLKS_ABSTRACT_FIELD_DETAILS(addrDetails)));
+            Q_ASSERT(addrValue);
+            folks_postal_address_set_po_box(addrValue, addr->postOfficeBox().toUtf8().data());
+            folks_postal_address_set_street(addrValue, addr->street().toUtf8().data());
+            folks_postal_address_set_locality(addrValue, addr->locality().toUtf8().data());
+            folks_postal_address_set_region(addrValue, addr->region().toUtf8().data());
+            folks_postal_address_set_postal_code(addrValue, addr->postcode().toUtf8().data());
+            folks_postal_address_set_country(addrValue, addr->country().toUtf8().data());
+        }
+
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(addrDetails), detail);
+        folks_postal_address_details_change_postal_addresses(FOLKS_POSTAL_ADDRESS_DETAILS(persona),
+                                                             addrSet,
                                                              (GAsyncReadyCallback) updateDetailsDone,
                                                              data);
-        g_object_unref(addressSet);
+        g_object_unref(addrDetails);
+        g_object_unref(addrSet);
+        g_object_unref(addrValue);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updateIms(QList<QtContacts::QContactDetail> details, void* data)
+void QIndividual::updateIm(QtContacts::QContactDetail detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalIms = m_contact.details(QContactDetail::TypeOnlineAccount);
-
-    if (FOLKS_IS_IM_DETAILS(udata->m_persona) && !detailListIsEqual(originalIms, details)) {
-        GeeMultiMap *imAddressHash = GEE_MULTI_MAP_AFD_NEW(FOLKS_TYPE_IM_FIELD_DETAILS);
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactOnlineAccount *im = static_cast<const QContactOnlineAccount*>(&detail);
-            if (!im->accountUri().isEmpty()) {
-                FolksImFieldDetails *imfd = folks_im_field_details_new(im->accountUri().toUtf8().data(), NULL);
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(imfd), detail);
-                gee_multi_map_set(imAddressHash,
-                                  onlineAccountProtocolFromEnum(im->protocol()).toUtf8().data(), imfd);
-                g_object_unref(imfd);
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalIm = detailFromUri(QContactDetail::TypeOnlineAccount, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseImDetails, data);
+    } else if (FOLKS_IS_IM_DETAILS(persona) && (originalIm != detail)) {
+        const QContactOnlineAccount *im = static_cast<const QContactOnlineAccount*>(&detail);
+        GeeMultiMap *imSet = folks_im_details_get_im_addresses(FOLKS_IM_DETAILS(persona));
+
+        if (!imSet || (gee_multi_map_get_size(GEE_MULTI_MAP(imSet)) == 0)) {
+            imSet = GEE_MULTI_MAP_AFD_NEW(FOLKS_TYPE_IM_FIELD_DETAILS);
+        } else {
+            // We can not relay on the index inside of detailUri because online account are stored in a hash
+            QContactOnlineAccount oldIm = static_cast<QContactOnlineAccount>(originalIm);
+            QString oldProtocolName = onlineAccountProtocolFromEnum(oldIm.protocol());
+            GeeCollection *value = gee_multi_map_get(imSet, oldProtocolName.toUtf8().data());
+
+            // Remove the old one
+            if (value) {
+                // if there is more than one address only remove the correct one
+                if (gee_collection_get_size(value) > 1) {
+                    gee_collection_remove(value, oldIm.accountUri().toUtf8().data());
+                } else {
+                    // otherwise remove the key
+                    gee_multi_map_remove_all(imSet, oldProtocolName.toUtf8().data());
+                }
             }
+
+            g_object_ref(imSet);
         }
 
-        folks_im_details_change_im_addresses(FOLKS_IM_DETAILS(udata->m_persona),
-                                             imAddressHash,
+        // Append the new one
+        FolksImFieldDetails *imDetails = folks_im_field_details_new(im->accountUri().toUtf8().data(), NULL);
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(imDetails), detail);
+
+        gee_multi_map_set(imSet,
+                          onlineAccountProtocolFromEnum(im->protocol()).toUtf8().data(),
+                          imDetails);
+
+        folks_im_details_change_im_addresses(FOLKS_IM_DETAILS(persona),
+                                             imSet,
                                              (GAsyncReadyCallback) updateDetailsDone,
                                              data);
-        g_object_unref(imAddressHash);
+        g_object_unref(imSet);
+        g_object_unref(imDetails);
     } else {
-        updateDetailsDone(G_OBJECT(udata->m_persona), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updateUrls(QList<QtContacts::QContactDetail> details, void* data)
+void QIndividual::updateUrl(QtContacts::QContactDetail detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalUrls = m_contact.details(QContactDetail::TypeUrl);
-
-    if (FOLKS_IS_URL_DETAILS(udata->m_persona) && !detailListIsEqual(originalUrls, details)) {
-        GeeSet *urlSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactUrl *url = static_cast<const QContactUrl*>(&detail);
-
-            if(!url->isEmpty()) {
-                FolksUrlFieldDetails *urlDetails = folks_url_field_details_new(url->url().toUtf8().data(), NULL);
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(urlDetails), detail);
-                gee_collection_add(GEE_COLLECTION(urlSet), urlDetails);
-                g_object_unref(urlDetails);
-            }
-        }
-        folks_url_details_change_urls(FOLKS_URL_DETAILS(udata->m_persona),
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalUrl = detailFromUri(QContactDetail::TypeUrl, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseUrlDetails, data);
+    } else if (FOLKS_IS_URL_DETAILS(persona) && (originalUrl != detail)) {
+        FolksUrlFieldDetails *urlDetails = 0;
+        const QContactUrl *url = static_cast<const QContactUrl*>(&detail);
+        GeeSet *urlSet = folks_url_details_get_urls(FOLKS_URL_DETAILS(persona));
+
+        if (!urlSet || (gee_collection_get_size(GEE_COLLECTION(urlSet)) == 0)) {
+            urlSet = SET_AFD_NEW();
+        } else {
+            urlDetails = FOLKS_URL_FIELD_DETAILS(QIndividualUtils::getDetails(urlSet, detail.detailUri()));
+
+            // this will be unref at the end of the function
+            g_object_ref(urlSet);
+            g_object_ref(urlDetails);
+        }
+
+        if (!urlDetails) {
+            urlDetails = folks_url_field_details_new(url->url().toUtf8().data(), NULL);
+            gee_collection_add(GEE_COLLECTION(urlSet), urlDetails);
+        } else {
+            folks_abstract_field_details_set_value(FOLKS_ABSTRACT_FIELD_DETAILS(urlDetails),
+                                                   url->url().toUtf8().data());
+        }
+
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(urlDetails), detail);
+        folks_url_details_change_urls(FOLKS_URL_DETAILS(persona),
                                       urlSet,
                                       (GAsyncReadyCallback) updateDetailsDone,
                                       data);
+        g_object_unref(urlDetails);
         g_object_unref(urlSet);
     } else {
-        updateDetailsDone(G_OBJECT(m_individual), NULL, data);
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
     }
 }
 
-void QIndividual::updateNotes(QList<QtContacts::QContactDetail> details, void* data)
+void QIndividual::updateNote(QtContacts::QContactDetail detail, void* data)
 {
-    UpdateContactData *udata = static_cast<UpdateContactData*>(data);
-    QList<QContactDetail> originalNotes = m_contact.details(QContactDetail::TypeNote);
-
-    if (FOLKS_IS_NOTE_DETAILS(udata->m_persona) && !detailListIsEqual(originalNotes, details)) {
-        GeeSet *noteSet = SET_AFD_NEW();
-        Q_FOREACH(const QContactDetail& detail, details) {
-            const QContactNote *note = static_cast<const QContactNote*>(&detail);
-
-            if(!note->isEmpty()) {
-                FolksNoteFieldDetails *noteDetails = folks_note_field_details_new(note->note().toUtf8().data(), NULL, 0);
-
-                //TODO: set context
-                gee_collection_add(GEE_COLLECTION(noteSet), noteDetails);
-                g_object_unref(noteDetails);
-            }
-        }
-        folks_note_details_change_notes(FOLKS_NOTE_DETAILS(udata->m_persona),
+    FolksPersona *persona = QIndividualUtils::personaFromUri(detail.detailUri(), m_individual, primaryPersona());
+    QContactDetail originalNote = detailFromUri(QContactDetail::TypeNote, detail.detailUri());
+
+    if (!persona) {
+        createPersonaForDetail(QList<QContactDetail>() << detail, QIndividual::parseNoteDetails, data);
+    } else if (FOLKS_IS_URL_DETAILS(persona) && (originalNote != detail)) {
+        FolksNoteFieldDetails *noteDetails = 0;
+        const QContactNote *note = static_cast<const QContactNote*>(&detail);
+        GeeSet *noteSet = folks_note_details_get_notes(FOLKS_NOTE_DETAILS(persona));
+
+        if (!noteSet || (gee_collection_get_size(GEE_COLLECTION(noteSet)) == 0)) {
+            noteSet = SET_AFD_NEW();
+        } else {
+            noteDetails = FOLKS_NOTE_FIELD_DETAILS(QIndividualUtils::getDetails(noteSet, detail.detailUri()));
+
+            // this will be unref at the end of the function
+            g_object_ref(noteSet);
+            g_object_ref(noteDetails);
+        }
+
+        if (!noteDetails) {
+            noteDetails = folks_note_field_details_new(note->note().toUtf8().data(), NULL, 0);
+            gee_collection_add(GEE_COLLECTION(noteSet), noteDetails);
+        } else {
+            folks_abstract_field_details_set_value(FOLKS_ABSTRACT_FIELD_DETAILS(noteDetails),
+                                                   note->note().toUtf8().data());
+        }
+
+        parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(noteDetails), detail);
+        folks_note_details_change_notes(FOLKS_NOTE_DETAILS(persona),
                                         noteSet,
                                         (GAsyncReadyCallback) updateDetailsDone,
-                                        data);
+                                        data);;
+        g_object_unref(noteDetails);
         g_object_unref(noteSet);
     } else {
-        updateDetailsDone(G_OBJECT(m_individual), NULL, data);
-    }
-}
-
+        updateDetailsDone(G_OBJECT(persona), NULL, data);
+    }
+}
+
+QString QIndividual::callDetailChangeFinish(QtContacts::QContactDetail::DetailType detailType,
+                                            FolksPersona *persona,
+                                            GAsyncResult *result)
+{
+    Q_ASSERT(persona);
+    Q_ASSERT(result);
+
+    GError *error = 0;
+    switch(detailType) {
+    case QContactDetail::TypeAddress:
+        folks_postal_address_details_change_postal_addresses_finish(FOLKS_POSTAL_ADDRESS_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeAvatar:
+        folks_avatar_details_change_avatar_finish(FOLKS_AVATAR_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeBirthday:
+        folks_birthday_details_change_birthday_finish(FOLKS_BIRTHDAY_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeDisplayLabel:
+        folks_name_details_change_full_name_finish(FOLKS_NAME_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeEmailAddress:
+        folks_email_details_change_email_addresses_finish(FOLKS_EMAIL_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeName:
+        folks_name_details_change_structured_name_finish(FOLKS_NAME_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeNickname:
+        folks_name_details_change_nickname_finish(FOLKS_NAME_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeNote:
+        folks_note_details_change_notes_finish(FOLKS_NOTE_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeOnlineAccount:
+        folks_im_details_change_im_addresses_finish(FOLKS_IM_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeOrganization:
+        folks_role_details_change_roles_finish(FOLKS_ROLE_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypePhoneNumber:
+        folks_phone_details_change_phone_numbers_finish(FOLKS_PHONE_DETAILS(persona), result, &error);
+        break;
+    case QContactDetail::TypeUrl:
+        folks_url_details_change_urls_finish(FOLKS_URL_DETAILS(persona), result, &error);
+    default:
+        break;
+    }
+
+    QString errorMessage;
+    if (error) {
+        errorMessage = QString::fromUtf8(error->message);
+        g_error_free(error);
+    }
+    return errorMessage;
+}
+
+void QIndividual::updateDetailsSendReply(gpointer userdata, const QString &errorMessage)
+{
+    UpdateContactData *data = static_cast<UpdateContactData*>(userdata);
+    data->m_slot.invoke(data->m_object,
+                        Q_ARG(QIndividual*, data->m_self), Q_ARG(QString, errorMessage));
+    delete data;
+}
+
+void QIndividual::updateDetailsSendReply(gpointer userdata, GError *error)
+{
+    QString errorMessage;
+    if (error) {
+        errorMessage = QString::fromUtf8(error->message);
+        qWarning() << error->message;
+        g_error_free(error);
+    }
+    updateDetailsSendReply(userdata, errorMessage);
+}
+
+
+void QIndividual::createPersonaDone(GObject *aggregator, GAsyncResult *result, gpointer userdata)
+{
+    qDebug() << Q_FUNC_INFO;
+    UpdateContactData *data = static_cast<UpdateContactData*>(userdata);
+
+    // A new persona was create to store the new data
+    GError *error = 0;
+    FolksPersona *newPersona = folks_individual_aggregator_add_persona_from_details_finish(FOLKS_INDIVIDUAL_AGGREGATOR(aggregator),
+                                                                                           result,
+                                                                                           &error);
+    if (error) {
+        updateDetailsSendReply(data, error);
+    } else {
+        // Link the new personas
+        GeeSet *personas = folks_individual_get_personas(data->m_self->m_individual);
+        GeeSet *newPersonas = SET_PERSONA_NEW();
+        gee_collection_add_all(GEE_COLLECTION(newPersonas), GEE_COLLECTION(personas));
+        gee_collection_add(GEE_COLLECTION(newPersonas), newPersona);
+        data->m_self->m_primaryPersona = newPersona;
+        folks_individual_aggregator_link_personas(data->m_self->m_aggregator, newPersonas, updateDetailsDone, userdata);
+    }
+}
 
 void QIndividual::updateDetailsDone(GObject *detail, GAsyncResult *result, gpointer userdata)
 {
-    GError *error = 0;
+    QString errorMessage;
     UpdateContactData *data = static_cast<UpdateContactData*>(userdata);
-
-    switch(data->m_currentDetailType) {
+    if (result && !data->m_currentDetail.isEmpty()) {
+        if (FOLKS_IS_PERSONA(detail)) {
+            // This is a normal field update
+            errorMessage = QIndividual::callDetailChangeFinish(data->m_currentDetail.type(),
+                                                               FOLKS_PERSONA(detail),
+                                                               result);
+        } else if (FOLKS_IS_INDIVIDUAL_AGGREGATOR(detail)) {
+            GError *error = 0;
+            folks_individual_aggregator_link_personas_finish(FOLKS_INDIVIDUAL_AGGREGATOR(detail), result, &error);
+            if (error) {
+                errorMessage = QString::fromUtf8(error->message);
+            }
+        }
+
+        if (!errorMessage.isEmpty()) {
+            updateDetailsSendReply(data, errorMessage);
+            return;
+        }
+    }
+
+    if (data->m_details.isEmpty()) {
+        updateDetailsSendReply(data, 0);
+        return;
+    }
+
+
+    data->m_currentDetail = data->m_details.takeFirst();
+    switch(data->m_currentDetail.type()) {
     case QContactDetail::TypeAddress:
-        if (result) {
-            folks_postal_address_details_change_postal_addresses_finish(FOLKS_POSTAL_ADDRESS_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeAvatar;
-            data->m_self->updatePhoto(data->m_newContact.detail(QContactDetail::TypeAvatar), data);
-            return;
-        }
+        data->m_self->updateAddress(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeAvatar:
-        if (result) {
-            folks_avatar_details_change_avatar_finish(FOLKS_AVATAR_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeBirthday;
-            data->m_self->updateBirthday(data->m_newContact.detail(QContactDetail::TypeBirthday), data);
-            return;
-        }
+        data->m_self->updatePhoto(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeBirthday:
-        if (result) {
-            folks_birthday_details_change_birthday_finish(FOLKS_BIRTHDAY_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeDisplayLabel;
-            data->m_self->updateFullName(data->m_newContact.detail(QContactDetail::TypeDisplayLabel), data);
-            return;
-        }
+        data->m_self->updateBirthday(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeDisplayLabel:
-        if (result) {
-            folks_name_details_change_full_name_finish(FOLKS_NAME_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeEmailAddress;
-            data->m_self->updateEmails(data->m_newContact.details(QContactDetail::TypeEmailAddress), data);
-            return;
-        }
+        data->m_self->updateFullName(data->m_currentDetail, data);
         break;
-
     case QContactDetail::TypeEmailAddress:
-        if (result) {
-            folks_email_details_change_email_addresses_finish(FOLKS_EMAIL_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeName;
-            data->m_self->updateName(data->m_newContact.detail(QContactDetail::TypeName), data);
-            return;
-        }
+        data->m_self->updateEmail(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeName:
-        if (result) {
-            folks_name_details_change_structured_name_finish(FOLKS_NAME_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeNickname;
-            data->m_self->updateNickname(data->m_newContact.detail(QContactDetail::TypeNickname), data);
-            return;
-        }
+        data->m_self->updateName(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeNickname:
-        if (result) {
-            folks_name_details_change_nickname_finish(FOLKS_NAME_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeNote;
-            data->m_self->updateNotes(data->m_newContact.details(QContactDetail::TypeNote), data);
-            return;
-        }
+        data->m_self->updateNickname(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeNote:
-        if (result) {
-            folks_note_details_change_notes_finish(FOLKS_NOTE_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeOnlineAccount;
-            data->m_self->updateIms(data->m_newContact.details(QContactDetail::TypeOnlineAccount), data);
-            return;
-        }
+        data->m_self->updateNote(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeOnlineAccount:
-        if (result) {
-            folks_im_details_change_im_addresses_finish(FOLKS_IM_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeOrganization;
-            data->m_self->updateRoles(data->m_newContact.details(QContactDetail::TypeOrganization), data);
-            return;
-        }
+        data->m_self->updateIm(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeOrganization:
-        if (result) {
-            folks_role_details_change_roles_finish(FOLKS_ROLE_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypePhoneNumber;
-            data->m_self->updatePhones(data->m_newContact.details(QContactDetail::TypePhoneNumber), data);
-            return;
-        }
+        data->m_self->updateRole(data->m_currentDetail, data);
         break;
     case QContactDetail::TypePhoneNumber:
-        if (result) {
-            folks_phone_details_change_phone_numbers_finish(FOLKS_PHONE_DETAILS(data->m_persona), result, &error);
-        }
-        if (!error) {
-            data->m_currentDetailType = QContactDetail::TypeUrl;
-            data->m_self->updateUrls(data->m_newContact.details(QContactDetail::TypeUrl), data);
-            return;
-        }
+        data->m_self->updatePhone(data->m_currentDetail, data);
         break;
     case QContactDetail::TypeUrl:
-        if (result) {
-            folks_url_details_change_urls_finish(FOLKS_URL_DETAILS(data->m_persona), result, &error);
-        }
+        data->m_self->updateUrl(data->m_currentDetail, data);
+        break;
     default:
+        qWarning() << "Update not implemented for" << data->m_currentDetail.type();
+        updateDetailsDone(0, 0, data);
         break;
     }
-
-    QString errorMessage;
-    if (error) {
-        errorMessage = QString::fromUtf8(error->message);
-        g_error_free(error);
-    }
-
-    qDebug() << "Update done" << errorMessage;
-    data->m_doneCB(errorMessage, data->m_doneData);
-    delete data;
 }
 
-
-bool QIndividual::update(const QtContacts::QContact &newContact, UpdateDoneCB cb, void* userData)
+bool QIndividual::update(const QtContacts::QContact &newContact, QObject *object, const QString &slot)
 {
+    int slotIndex = object->metaObject()->indexOfSlot(QMetaObject::normalizedSignature(slot.toUtf8().data()));
+    if (slotIndex == -1) {
+        qWarning() << "Invalid slot:" << slot << "for object" << object;
+        return false;
+    }
+
     QContact &originalContact = contact();
     if (newContact != originalContact) {
 
         UpdateContactData *data = new UpdateContactData;
-        data->m_currentDetailType = QContactDetail::TypeAddress;
+        data->m_details = newContact.details();
         data->m_newContact = newContact;
         data->m_self = this;
-        data->m_doneCB = cb;
-        data->m_doneData = userData;
-        data->m_persona = primaryPersona();
-
-        updateAddresses(newContact.details(QContactDetail::TypeAddress), data);
+        data->m_object = object;
+        data->m_slot = object->metaObject()->method(slotIndex);
+        updateDetailsDone(0, 0, data);
         return true;
     } else {
         qDebug() << "Contact is equal";
@@ -1160,10 +1449,26 @@
     return m_individual;
 }
 
-bool QIndividual::update(const QString &vcard, UpdateDoneCB cb, void* data)
+void QIndividual::setIndividual(FolksIndividual *individual)
+{
+    if (m_individual != individual) {
+        if (m_individual) {
+            g_object_unref(m_individual);
+        }
+        m_individual = individual;
+        if (m_individual) {
+            g_object_ref(m_individual);
+        }
+        // initialize qcontact
+        m_contact = QContact();
+        updateContact();
+    }
+}
+
+bool QIndividual::update(const QString &vcard, QObject *object, const QString &slot)
 {
     QContact contact = VCardParser::vcardToContact(vcard);
-    return update(contact, cb, data);
+    return update(contact, object, slot);
 }
 
 QStringList QIndividual::listParameters(FolksAbstractFieldDetails *details)
@@ -1532,31 +1837,26 @@
     return map[QContactOnlineAccount::ProtocolUnknown];
 }
 
-GHashTable *QIndividual::parseDetails(const QtContacts::QContact &contact)
+GHashTable *QIndividual::parseAddressDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
 {
-    GHashTable *details = g_hash_table_new_full(g_str_hash,
-                                                g_str_equal,
-                                                NULL,
-                                                (GDestroyNotify) QIndividualUtils::gValueSliceFree);
-     GValue *value;
-
-     /*
-      * Addresses
-      */
-    QList<QContactAddress> addresses = contact.details<QContactAddress>();
-    if(addresses.size() > 0) {
-    value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
-    Q_FOREACH(const QContactAddress& address, addresses) {
-        if(!address.isEmpty()) {
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        if(!detail.isEmpty()) {
+            QContactAddress address = static_cast<QContactAddress>(detail);
             FolksPostalAddress *postalAddress = folks_postal_address_new(address.postOfficeBox().toUtf8().data(),
-                                                                          NULL, // extension
-                                                                          address.street().toUtf8().data(),
-                                                                          address.locality().toUtf8().data(),
-                                                                          address.region().toUtf8().data(),
-                                                                          address.postcode().toUtf8().data(),
-                                                                          address.country().toUtf8().data(),
-                                                                          NULL,  // address format
-                                                                          NULL); //UID
+                                                                         NULL, // extension
+                                                                         address.street().toUtf8().data(),
+                                                                         address.locality().toUtf8().data(),
+                                                                         address.region().toUtf8().data(),
+                                                                         address.postcode().toUtf8().data(),
+                                                                         address.country().toUtf8().data(),
+                                                                         NULL,  // address format
+                                                                         NULL); //UID
 
             GeeCollection *collection = (GeeCollection*) g_value_get_object(value);
             if(collection == NULL) {
@@ -1570,188 +1870,318 @@
 
             g_object_unref(pafd);
             g_object_unref(postalAddress);
-            }
         }
         QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_POSTAL_ADDRESSES, value);
     }
 
-
-    /*
-      * Avatar
-      */
-     QContactAvatar avatar = contact.detail<QContactAvatar>();
-     if(!avatar.isEmpty()) {
-         value = QIndividualUtils::gValueSliceNew(G_TYPE_FILE_ICON);
-         QUrl avatarUri = avatar.imageUrl();
-         if(!avatarUri.isEmpty()) {
-             QString formattedUri = avatarUri.toString(QUrl::RemoveUserInfo);
-             if(!formattedUri.isEmpty()) {
-                 GFile *avatarFile = g_file_new_for_uri(formattedUri.toUtf8().data());
-                 GFileIcon *avatarFileIcon = G_FILE_ICON(g_file_icon_new(avatarFile));
-                 g_value_take_object(value, avatarFileIcon);
-
-                 QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_AVATAR, value);
-                 g_clear_object((GObject**) &avatarFile);
-             }
-         }
-     }
-
-    /*
-    * Birthday
-    */
-    QContactBirthday birthday = contact.detail<QContactBirthday>();
-    if(!birthday.isEmpty()) {
-        value = QIndividualUtils::gValueSliceNew(G_TYPE_DATE_TIME);
-        GDateTime *dateTime = g_date_time_new_from_unix_utc(birthday.dateTime().toMSecsSinceEpoch() / 1000);
-        g_value_set_boxed(value, dateTime);
-
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_BIRTHDAY, value);
-        g_date_time_unref(dateTime);
-    }
-
-    /*
-    * Email addresses
-    */
-    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details,
+    return details;
+}
+
+GHashTable *QIndividual::parsePhotoDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactAvatar avatar = static_cast<QContactAvatar>(detail);
+        if(!avatar.isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_FILE_ICON);
+            QUrl avatarUri = avatar.imageUrl();
+            if(!avatarUri.isEmpty()) {
+                QString formattedUri = avatarUri.toString(QUrl::RemoveUserInfo);
+                if(!formattedUri.isEmpty()) {
+                    GFile *avatarFile = g_file_new_for_uri(formattedUri.toUtf8().data());
+                    GFileIcon *avatarFileIcon = G_FILE_ICON(g_file_icon_new(avatarFile));
+                    g_value_take_object(value, avatarFileIcon);
+
+                    QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_AVATAR, value);
+                    g_clear_object((GObject**) &avatarFile);
+                }
+            } else {
+                g_object_unref(value);
+            }
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseBirthdayDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactBirthday birthday = static_cast<QContactBirthday>(detail);
+        if(!birthday.isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_DATE_TIME);
+            GDateTime *dateTime = g_date_time_new_from_unix_utc(birthday.dateTime().toMSecsSinceEpoch() / 1000);
+            g_value_set_boxed(value, dateTime);
+
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_BIRTHDAY, value);
+            g_date_time_unref(dateTime);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseEmailDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value;
+    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details, cDetails,
                                                 FOLKS_PERSONA_DETAIL_EMAIL_ADDRESSES, value, QContactEmailAddress,
                                                 FOLKS_TYPE_EMAIL_FIELD_DETAILS, emailAddress);
-
-    /*
-    * Favorite
-    */
-    QContactFavorite favorite = contact.detail<QContactFavorite>();
-    if(!favorite.isEmpty()) {
-        value = QIndividualUtils::gValueSliceNew(G_TYPE_BOOLEAN);
-        g_value_set_boolean(value, favorite.isFavorite());
-
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_IS_FAVOURITE, value);
-    }
-
-    /*
-    * Gender
-    */
-    QContactGender gender = contact.detail<QContactGender>();
-    if(!gender.isEmpty()) {
-        value = QIndividualUtils::gValueSliceNew(FOLKS_TYPE_GENDER);
-        FolksGender genderEnum = FOLKS_GENDER_UNSPECIFIED;
-        if(gender.gender() == QContactGender::GenderMale) {
-            genderEnum = FOLKS_GENDER_MALE;
-        } else if(gender.gender() == QContactGender::GenderFemale) {
-            genderEnum = FOLKS_GENDER_FEMALE;
-        }
-        g_value_set_enum(value, genderEnum);
-
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_GENDER, value);
-    }
-
-    /*
-    * Names
-    */
-    QContactName name = contact.detail<QContactName>();
-    if(!name.isEmpty()) {
-        value = QIndividualUtils::gValueSliceNew(FOLKS_TYPE_STRUCTURED_NAME);
-        FolksStructuredName *sn = folks_structured_name_new(name.lastName().toUtf8().data(),
-                                                            name.firstName().toUtf8().data(),
-                                                            name.middleName().toUtf8().data(),
-                                                            name.prefix().toUtf8().data(),
-                                                            name.suffix().toUtf8().data());
-        g_value_take_object(value, sn);
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_STRUCTURED_NAME, value);
-    }
-
-    QContactDisplayLabel displayLabel = contact.detail<QContactDisplayLabel>();
-    if(!displayLabel.label().isEmpty()) {
-        value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
-        g_value_set_string(value, displayLabel.label().toUtf8().data());
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_FULL_NAME, value);
-
-        // FIXME: check if those values should all be set to the same thing
-        value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
-        g_value_set_string(value, displayLabel.label().toUtf8().data());
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_ALIAS, value);
-    }
-
-    /*
-    * Notes
-    */
-    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details,
+    return details;
+}
+
+GHashTable *QIndividual::parseFavoriteDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactFavorite favorite = static_cast<QContactFavorite>(detail);
+        if(!favorite.isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_BOOLEAN);
+            g_value_set_boolean(value, favorite.isFavorite());
+
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_IS_FAVOURITE, value);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseGenderDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactGender gender = static_cast<QContactDetail>(detail);
+        if(!gender.isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(FOLKS_TYPE_GENDER);
+            FolksGender genderEnum = FOLKS_GENDER_UNSPECIFIED;
+            if(gender.gender() == QContactGender::GenderMale) {
+                genderEnum = FOLKS_GENDER_MALE;
+            } else if(gender.gender() == QContactGender::GenderFemale) {
+                genderEnum = FOLKS_GENDER_FEMALE;
+            }
+            g_value_set_enum(value, genderEnum);
+
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_GENDER, value);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseNameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactName name = static_cast<QContactName>(detail);
+        if(!name.isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(FOLKS_TYPE_STRUCTURED_NAME);
+            FolksStructuredName *sn = folks_structured_name_new(name.lastName().toUtf8().data(),
+                                                                name.firstName().toUtf8().data(),
+                                                                name.middleName().toUtf8().data(),
+                                                                name.prefix().toUtf8().data(),
+                                                                name.suffix().toUtf8().data());
+            g_value_take_object(value, sn);
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_STRUCTURED_NAME, value);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseFullNameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactDisplayLabel displayLabel = static_cast<QContactDisplayLabel>(detail);
+        if(!displayLabel.label().isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
+            g_value_set_string(value, displayLabel.label().toUtf8().data());
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_FULL_NAME, value);
+
+            // FIXME: check if those values should all be set to the same thing
+            value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
+            g_value_set_string(value, displayLabel.label().toUtf8().data());
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_ALIAS, value);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseNicknameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactNickname nickname = static_cast<QContactNickname>(detail);
+        if(!nickname.nickname().isEmpty()) {
+            GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
+            g_value_set_string(value, nickname.nickname().toUtf8().data());
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_NICKNAME, value);
+
+            // FIXME: check if those values should all be set to the same thing
+            value = QIndividualUtils::gValueSliceNew(G_TYPE_STRING);
+            g_value_set_string(value, nickname.nickname().toUtf8().data());
+            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_ALIAS, value);
+        }
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseNoteDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value;
+    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details, cDetails,
                                                 FOLKS_PERSONA_DETAIL_NOTES, value, QContactNote,
                                                 FOLKS_TYPE_NOTE_FIELD_DETAILS, note);
 
-
-
-    /*
-    * OnlineAccounts
-    */
-    QList<QContactOnlineAccount> accounts = contact.details<QContactOnlineAccount>();
-    if(!accounts.isEmpty()) {
-        QMultiMap<QString, QString> providerUidMap;
-
-        Q_FOREACH(const QContactOnlineAccount &account, accounts) {
-            if (!account.isEmpty()) {
-                providerUidMap.insert(onlineAccountProtocolFromEnum(account.protocol()), account.accountUri());
-            }
-        }
-
-        if(!providerUidMap.isEmpty()) {
-            //TODO: add account type and subtype
-            value = QIndividualUtils::asvSetStrNew(providerUidMap);
-            QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_IM_ADDRESSES, value);
-        }
-    }
-
-    /*
-    * Organization
-    */
-    QList<QContactOrganization> orgs = contact.details<QContactOrganization>();
-    if(orgs.size() > 0) {
-        value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
-        Q_FOREACH(const QContactOrganization& org, orgs) {
-            if(!org.isEmpty()) {
-                FolksRole *role = folks_role_new(org.title().toUtf8().data(),
-                                                 org.name().toUtf8().data(),
-                                                 NULL);
-                folks_role_set_role(role, org.role().toUtf8().data());
-
-                GeeCollection *collection = (GeeCollection*) g_value_get_object(value);
-                if(collection == NULL) {
-                    collection = GEE_COLLECTION(SET_AFD_NEW());
-                    g_value_take_object(value, collection);
-                }
-                FolksRoleFieldDetails *rfd = folks_role_field_details_new(role, NULL);
-                parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(rfd), org);
-                gee_collection_add(collection, rfd);
-
-                g_object_unref(rfd);
-                g_object_unref(role);
-            }
-        }
-        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_ROLES, value);
-    }
-
-     /*
-      * Phone Numbers
-      */
-     QList<QContactPhoneNumber> phones = contact.details<QContactPhoneNumber>();
-     if (phones.size() > 0) {
-         value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
-         Q_FOREACH(const QContactPhoneNumber &phone, phones) {
-             if(!phone.isEmpty()) {
-                 QIndividualUtils::gValueGeeSetAddStringFieldDetails(value,
-                                                                     FOLKS_TYPE_PHONE_FIELD_DETAILS,
-                                                                     phone.number().toUtf8().data(),
-                                                                     phone);
-             }
-         }
-         QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_PHONE_NUMBERS, value);
-     }
-
-    /*
-    * URLs
-    */
-    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details,
+    return details;
+}
+
+GHashTable *QIndividual::parseImDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    QMultiMap<QString, QString> providerUidMap;
+    Q_FOREACH(const QContactDetail &detail, cDetails) {
+        QContactOnlineAccount account = static_cast<QContactOnlineAccount>(detail);
+        if (!account.isEmpty()) {
+            providerUidMap.insert(onlineAccountProtocolFromEnum(account.protocol()), account.accountUri());
+        }
+    }
+
+    if(!providerUidMap.isEmpty()) {
+        //TODO: add account type and subtype
+        GValue *value = QIndividualUtils::asvSetStrNew(providerUidMap);
+        QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_IM_ADDRESSES, value);
+    }
+
+    return details;
+}
+
+GHashTable *QIndividual::parseOrganizationDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
+    Q_FOREACH(const QContactDetail& detail, cDetails) {
+        QContactOrganization org = static_cast<QContactOrganization>(detail);
+        if(!org.isEmpty()) {
+            FolksRole *role = folks_role_new(org.title().toUtf8().data(),
+                                             org.name().toUtf8().data(),
+                                             NULL);
+            folks_role_set_role(role, org.role().toUtf8().data());
+
+            GeeCollection *collection = (GeeCollection*) g_value_get_object(value);
+            if(collection == NULL) {
+                collection = GEE_COLLECTION(SET_AFD_NEW());
+                g_value_take_object(value, collection);
+            }
+            FolksRoleFieldDetails *rfd = folks_role_field_details_new(role, NULL);
+            parseContext(FOLKS_ABSTRACT_FIELD_DETAILS(rfd), org);
+            gee_collection_add(collection, rfd);
+
+            g_object_unref(rfd);
+            g_object_unref(role);
+        }
+    }
+    QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_ROLES, value);
+
+    return details;
+}
+
+GHashTable *QIndividual::parsePhoneNumbersDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value = QIndividualUtils::gValueSliceNew(G_TYPE_OBJECT);
+    Q_FOREACH(const QContactDetail &detail, cDetails) {
+        QContactPhoneNumber phone = static_cast<QContactPhoneNumber>(detail);
+        if(!phone.isEmpty()) {
+            QIndividualUtils::gValueGeeSetAddStringFieldDetails(value,
+                                                                FOLKS_TYPE_PHONE_FIELD_DETAILS,
+                                                                phone.number().toUtf8().data(),
+                                                                phone);
+        }
+    }
+    QIndividualUtils::personaDetailsInsert(details, FOLKS_PERSONA_DETAIL_PHONE_NUMBERS, value);
+
+    return details;
+}
+
+GHashTable *QIndividual::parseUrlDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails)
+{
+    if(cDetails.size() == 0) {
+        return details;
+    }
+
+    GValue *value;
+    PERSONA_DETAILS_INSERT_STRING_FIELD_DETAILS(details, cDetails,
                                                 FOLKS_PERSONA_DETAIL_URLS, value, QContactUrl,
                                                 FOLKS_TYPE_URL_FIELD_DETAILS, url);
+
+    return details;
+}
+
+
+GHashTable *QIndividual::parseDetails(const QtContacts::QContact &contact)
+{
+    GHashTable *details = g_hash_table_new_full(g_str_hash,
+                                                g_str_equal,
+                                                NULL,
+                                                (GDestroyNotify) QIndividualUtils::gValueSliceFree);
+
+    parseAddressDetails(details, contact.details(QContactAddress::Type));
+    parsePhotoDetails(details, contact.details(QContactAvatar::Type));
+    parseBirthdayDetails(details, contact.details(QContactBirthday::Type));
+    parseEmailDetails(details, contact.details(QContactEmailAddress::Type));
+    parseFavoriteDetails(details, contact.details(QContactFavorite::Type));
+    parseGenderDetails(details, contact.details(QContactGender::Type));
+    parseNameDetails(details, contact.details(QContactName::Type));
+    parseFullNameDetails(details, contact.details(QContactDisplayLabel::Type));
+    parseNicknameDetails(details, contact.details(QContactNickname::Type));
+    parseNoteDetails(details, contact.details(QContactNote::Type));
+    parseImDetails(details, contact.details(QContactOnlineAccount::Type));
+    parseOrganizationDetails(details, contact.details(QContactOrganization::Type));
+    parsePhoneNumbersDetails(details, contact.details(QContactPhoneNumber::Type));
+    parseUrlDetails(details, contact.details(QContactUrl::Type));
+
     return details;
 }
 
@@ -1761,29 +2191,39 @@
 {
 }
 
-FolksPersona* QIndividual::primaryPersona() const
+FolksPersona* QIndividual::primaryPersona()
 {
-    if(m_individual == 0) {
-        return 0;
+    Q_ASSERT(m_individual);
+
+    if (m_primaryPersona) {
+        return m_primaryPersona;
     }
 
-    FolksPersona *retval = NULL;
     GeeSet *personas = folks_individual_get_personas(m_individual);
     GeeIterator *iter = gee_iterable_iterator(GEE_ITERABLE(personas));
+    FolksPersonaStore *primaryStore = folks_individual_aggregator_get_primary_store(m_aggregator);
 
-    while(retval == NULL && gee_iterator_next(iter)) {
+    while(m_primaryPersona == NULL && gee_iterator_next(iter)) {
         FolksPersona *persona = FOLKS_PERSONA(gee_iterator_get(iter));
-        FolksPersonaStore *primaryStore = folks_individual_aggregator_get_primary_store(m_aggregator);
         if(folks_persona_get_store(persona) == primaryStore) {
-            retval = persona;
-            g_object_ref(retval);
+            m_primaryPersona = persona;
+            g_object_ref (persona);
         }
-
         g_object_unref(persona);
     }
     g_object_unref (iter);
 
-    return retval;
+    return m_primaryPersona;
+}
+
+QtContacts::QContactDetail QIndividual::detailFromUri(QtContacts::QContactDetail::DetailType type, const QString &uri) const
+{
+    Q_FOREACH(QContactDetail detail, m_contact.details(type)) {
+        if (detail.detailUri() == uri) {
+            return detail;
+        }
+    }
+    return m_contact.detail(type);
 }
 
 } //namespace

=== modified file 'src/qindividual.h'
--- src/qindividual.h	2013-06-11 13:00:01 +0000
+++ src/qindividual.h	2013-06-18 19:48:28 +0000
@@ -31,7 +31,7 @@
 
 namespace galera
 {
-typedef void (*UpdateDoneCB)(const QString&, void*);
+typedef GHashTable* (ParseDetailsFunc)(GHashTable*, const QList<QtContacts::QContactDetail> &);
 
 typedef QList<QtVersit::QVersitProperty> PropertyList;
 class QIndividual
@@ -59,40 +59,47 @@
 
     QtContacts::QContact &contact();
     QtContacts::QContact copy(Fields fields = QIndividual::All);
-    bool update(const QString &vcard, UpdateDoneCB cb, void* data);
-    bool update(const QtContacts::QContact &contact, UpdateDoneCB cb, void* data);
+    bool update(const QString &vcard, QObject *object, const QString &slot);
+    bool update(const QtContacts::QContact &contact, QObject *object, const QString &slot);
     FolksIndividual *individual() const;
+    void setIndividual(FolksIndividual *individual);
 
     static GHashTable *parseDetails(const QtContacts::QContact &contact);
-
 private:
     FolksIndividual *m_individual;
+    FolksPersona *m_primaryPersona;
     FolksIndividualAggregator *m_aggregator;
     QtContacts::QContact m_contact;
     QMap<QString, QPair<QtContacts::QContactDetail, FolksAbstractFieldDetails*> > m_fieldsMap;
-    unsigned int m_fieldMapNextKey;
+
 
     bool fieldsContains(Fields fields, Field value) const;
     QList<QtVersit::QVersitProperty> parseFieldList(const QString &fieldName, GeeSet *values) const;
     QMultiHash<QString, QString> parseDetails(FolksAbstractFieldDetails *details) const;
     void updateContact();
-    FolksPersona *primaryPersona() const;
+
+    FolksPersona *primaryPersona();
+    QtContacts::QContactDetail detailFromUri(QtContacts::QContactDetail::DetailType type, const QString &uri) const;
 
     // QContact
+    QList<QtContacts::QContactDetail> getDetails() const;
+    void appendDetailsForPersona(QList<QtContacts::QContactDetail> *list, QtContacts::QContactDetail detail, const QString &personaIndex, bool readOnly) const;
+    void appendDetailsForPersona(QList<QtContacts::QContactDetail> *list, QList<QtContacts::QContactDetail> details, const QString &personaIndex, bool readOnly) const;
+
     QtContacts::QContactDetail getUid() const;
     QList<QtContacts::QContactDetail> getClientPidMap() const;
-    QtContacts::QContactDetail getName() const;
-    QtContacts::QContactDetail getFullName() const;
-    QtContacts::QContactDetail getNickname() const;
-    QtContacts::QContactDetail getBirthday() const;
-    QtContacts::QContactDetail getPhoto() const;
-    QList<QtContacts::QContactDetail> getRoles() const;
-    QList<QtContacts::QContactDetail> getEmails() const;
-    QList<QtContacts::QContactDetail> getPhones() const;
-    QList<QtContacts::QContactDetail> getAddresses() const;
-    QList<QtContacts::QContactDetail> getIms() const;
-    QtContacts::QContactDetail getTimeZone() const;
-    QList<QtContacts::QContactDetail> getUrls() const;
+    QtContacts::QContactDetail getPersonaName(FolksPersona *persona) const;
+    QtContacts::QContactDetail getPersonaFullName(FolksPersona *persona) const;
+    QtContacts::QContactDetail getPersonaNickName(FolksPersona *persona) const;
+    QtContacts::QContactDetail getPersonaBirthday(FolksPersona *persona) const;
+    QtContacts::QContactDetail getPersonaPhoto(FolksPersona *persona) const;
+    //TODO: organization
+    QList<QtContacts::QContactDetail> getPersonaRoles(FolksPersona *persona) const;
+    QList<QtContacts::QContactDetail> getPersonaEmails(FolksPersona *persona) const;
+    QList<QtContacts::QContactDetail> getPersonaPhones(FolksPersona *persona) const;
+    QList<QtContacts::QContactDetail> getPersonaAddresses(FolksPersona *persona) const;
+    QList<QtContacts::QContactDetail> getPersonaIms(FolksPersona *persona) const;
+    QList<QtContacts::QContactDetail> getPersonaUrls(FolksPersona *persona) const;
 
 
     // update
@@ -102,15 +109,38 @@
     void updateBirthday(const QtContacts::QContactDetail &detail, void* data);
     void updatePhoto(const QtContacts::QContactDetail &detail, void* data);
     void updateTimezone(const QtContacts::QContactDetail &detail, void* data);
-    void updateRoles(QList<QtContacts::QContactDetail> details, void* data);
-    void updatePhones(QList<QtContacts::QContactDetail> details, void* data);
-    void updateEmails(QList<QtContacts::QContactDetail> details, void* data);
-    void updateIms(QList<QtContacts::QContactDetail> details, void* data);
-    void updateUrls(QList<QtContacts::QContactDetail> details, void* data);
-    void updateNotes(QList<QtContacts::QContactDetail> details, void* data);
-    void updateAddresses(QList<QtContacts::QContactDetail> details, void* data);
+    void updateRole(QtContacts::QContactDetail detail, void* data);
+    void updatePhone(QtContacts::QContactDetail detail, void* data);
+    void updateEmail(QtContacts::QContactDetail detail, void* data);
+    void updateIm(QtContacts::QContactDetail detail, void* data);
+    void updateUrl(QtContacts::QContactDetail details, void* data);
+    void updateNote(QtContacts::QContactDetail detail, void* data);
+    void updateAddress(QtContacts::QContactDetail detail, void* data);
+    void createPersonaForDetail(QList<QtContacts::QContactDetail> detail, ParseDetailsFunc parseFunc, void *data) const;
+
+    static void createPersonaDone(GObject *detail, GAsyncResult *result, gpointer userdata);
     static void updateDetailsDone(GObject *detail, GAsyncResult *result, gpointer userdata);
-    static bool detailListIsEqual(QList<QtContacts::QContactDetail> original, QList<QtContacts::QContactDetail> details);
+    static void updateDetailsSendReply(gpointer userdata, GError *error);
+    static void updateDetailsSendReply(gpointer userdata, const QString &errorMessage);
+    static QString callDetailChangeFinish(QtContacts::QContactDetail::DetailType type, FolksPersona *persona, GAsyncResult *result);
+    //static bool detailListIsEqual(QList<QtContacts::QContactDetail> original, QList<QtContacts::QContactDetail> details);
+
+    // translate details
+    static GHashTable *parseAddressDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parsePhotoDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parsePhoneNumbersDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseOrganizationDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseImDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseNoteDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseFullNameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseNicknameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseNameDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseGenderDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseFavoriteDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseEmailDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseBirthdayDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+    static GHashTable *parseUrlDetails(GHashTable *details, const QList<QtContacts::QContactDetail> &cDetails);
+
 
     // parse context and parameters
     static void parseParameters(QtContacts::QContactDetail &detail, FolksAbstractFieldDetails *fd);

=== modified file 'src/view-adaptor.h'
--- src/view-adaptor.h	2013-06-13 14:00:42 +0000
+++ src/view-adaptor.h	2013-06-18 19:48:28 +0000
@@ -45,7 +45,7 @@
 "      <arg direction=\"out\" type=\"i\" name=\"pos\"/>\n"
 "      <arg direction=\"out\" type=\"i\" name=\"lenght\"/>\n"
 "    </signal>\n"
-"    <signal name=\"contactsCreated\">\n"
+"    <signal name=\"contactsAdded\">\n"
 "      <arg direction=\"out\" type=\"i\" name=\"pos\"/>\n"
 "      <arg direction=\"out\" type=\"i\" name=\"lenght\"/>\n"
 "    </signal>\n"
@@ -81,7 +81,7 @@
     void close();
 
 Q_SIGNALS:
-    void contactsCreated(int pos, int lenght);
+    void contactsAdded(int pos, int lenght);
     void contactsRemoved(int pos, int lenght);
     void contactsUpdated(int pos, int lenght);
 

=== modified file 'src/view.cpp'
--- src/view.cpp	2013-06-13 14:35:08 +0000
+++ src/view.cpp	2013-06-18 19:48:28 +0000
@@ -86,6 +86,13 @@
         return m_contacts.removeAll(entry);
     }
 
+    void chageSort(SortClause clause)
+    {
+        m_sortClause = clause;
+        ContactLessThan lessThan(m_sortClause);
+        qSort(m_contacts.begin(), m_contacts.end(), lessThan);
+    }
+
 protected:
     void run()
     {
@@ -95,8 +102,8 @@
                 m_contacts << entry;
             }
         }
-        ContactLessThan lessThan(m_sortClause);
-        qSort(m_contacts.begin(), m_contacts.end(), lessThan);
+
+        chageSort(m_sortClause);
     }
 
 private:
@@ -180,6 +187,7 @@
 
 void View::sort(const QString &field)
 {
+    m_filterThread->chageSort(SortClause(field));
 }
 
 QString View::objectPath()