1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qcontactmaemo5backend_p.h"

    43 

    44 #include <QSharedData>

    45 #include <QTimer>

    46 

    47 #include "qcontactmaemo5debug_p.h"

    48 

    49 DEFINE_GLOBAL_DEBUG_VAR

    50 

    51 QContactManagerEngine* ContactMaemo5Factory::engine(const QMap<QString, QString>& parameters, QContactManager::Error* error)

    52 {

    53     Q_UNUSED(parameters);

    54     Q_UNUSED(error);

    55 

    56     initDebugLogger();

    57     return new QContactMaemo5Engine(); //FIXME Wonderfull memory leak :D

    58 }

    59 

    60 QString ContactMaemo5Factory::managerName() const

    61 {

    62     return QString("maemo5");

    63 }

    64 

    65 Q_EXPORT_PLUGIN2(qtcontacts_maemo5, ContactMaemo5Factory);

    66 

    67 /*!

    68   \class QContactMaemo5Engine

    69   \brief The QContactMaemo5Engine class provides an implementation of

    70   QContactManagerEngine whose functions always return an error.

    71   

    72   The Maemo5 engine.

    73  */

    74 

    75 /*! Constructs a new invalid contacts backend. */

    76 QContactMaemo5Engine::QContactMaemo5Engine() : d(new QContactMaemo5EngineData)

    77 {

    78   QContactABook *abook = d->m_abook;

    79   connect(abook, SIGNAL(contactsAdded(const QList<QContactLocalId>&)), SIGNAL(contactsAdded(const QList<QContactLocalId>&)));

    80   connect(abook, SIGNAL(contactsChanged(const QList<QContactLocalId>&)), SIGNAL(contactsChanged(const QList<QContactLocalId>&)));

    81   connect(abook, SIGNAL(contactsRemoved(const QList<QContactLocalId>&)), SIGNAL(contactsRemoved(const QList<QContactLocalId>&)));

    82 }

    83 

    84 /*! \reimp */

    85 QContactMaemo5Engine& QContactMaemo5Engine::operator=(const QContactMaemo5Engine& other)

    86 {

    87     d = other.d;

    88     return *this;

    89 }

    90 

    91 /*! \reimp */

    92 QString QContactMaemo5Engine::managerName() const

    93 {

    94     return QString(QLatin1String("maemo5"));

    95 }

    96 

    97 /* Synthesise the display label of a contact */

    98 QString QContactMaemo5Engine::synthesizedDisplayLabel(const QContact& contact, QContactManager::Error* error) const

    99 {

   100   QString label;

   101   

   102   // Try to get the display name from the OSSO-ABook Contact

   103   label = d->m_abook->getDisplayName(contact);

   104   

   105   // Synthesise the display label for not saved contacts

   106   // A. FirstName + LastName

   107   if (label.isEmpty()){

   108     QContactName name = contact.detail(QContactName::DefinitionName);

   109     QStringList nameList;

   110     

   111     nameList << name.firstName();

   112     if (name.lastName().count()){

   113       nameList << name.lastName();

   114     }

   115     

   116     label = nameList.join(QString(' '));

   117   }

   118   

   119   // B. Email

   120   if (label.isEmpty()){

   121     QContactEmailAddress email = contact.detail(QContactEmailAddress::DefinitionName);

   122     label = email.emailAddress();

   123   }

   124   

   125   // 

   126   if (label.isEmpty()){

   127     *error = QContactManager::UnspecifiedError;

   128     return QString("No name");

   129   }

   130   

   131   *error = QContactManager::NoError;

   132   return label;

   133 }

   134 

   135 bool QContactMaemo5Engine::validateContact(const QContact& contact, QContactManager::Error* error) const

   136 {

   137     return QContactManagerEngine::validateContact(contact, error);

   138 }

   139 

   140 bool QContactMaemo5Engine::validateDefinition(const QContactDetailDefinition& definition, QContactManager::Error* error) const

   141 {

   142     QContactDetailDefinition existing = detailDefinition(definition.name(), QContactType::TypeContact, error);

   143     if (existing == definition) {

   144         *error = QContactManager::NoError;

   145         return true;

   146     }

   147 

   148     *error = QContactManager::NotSupportedError; // XXX TODO: mutable definitions?

   149     return false;

   150 }

   151 

   152 QContact QContactMaemo5Engine::compatibleContact(const QContact& contact, QContactManager::Error* error) const

   153 {

   154     return QContactManagerEngine::compatibleContact(contact, error);

   155 }

   156 

   157 QContactLocalId QContactMaemo5Engine::selfContactId(QContactManager::Error* error) const

   158 {

   159   Q_CHECK_PTR(d->m_abook);

   160 

   161   return d->m_abook->selfContactId(error);

   162 }

   163 

   164 QList<QContactLocalId> QContactMaemo5Engine::contactIds(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders, QContactManager::Error* error) const

   165 {

   166   Q_CHECK_PTR(d->m_abook);

   167   

   168   QList<QContactLocalId> rtn;

   169 

   170   // do this naively for now...

   171   QContactManager::Error tempError = QContactManager::NoError;

   172   QList<QContactLocalId> allIds = d->m_abook->contactIds(filter, sortOrders, error);

   173   QList<QContact> sortedAndFiltered;

   174   

   175   foreach (const QContactLocalId& currId, allIds) {

   176     QContact curr = contact(currId, QContactFetchHint(), &tempError);

   177     if (tempError != QContactManager::NoError)

   178       *error = tempError;

   179     if (QContactManagerEngine::testFilter(filter, curr)) {

   180       QContactManagerEngine::addSorted(&sortedAndFiltered, curr, sortOrders);

   181     }

   182   }

   183 

   184   foreach (const QContact& contact, sortedAndFiltered) {

   185     rtn.append(contact.localId());

   186   }

   187   return rtn;

   188 }

   189 

   190 QList<QContact> QContactMaemo5Engine::contacts(const QContactFilter & filter, const QList<QContactSortOrder> & sortOrders, const QContactFetchHint & fetchHint,

   191 			  QContactManager::Error* error ) const

   192 {

   193   Q_UNUSED(fetchHint); // no optimisations currently, ignore the fetchhint.

   194   Q_CHECK_PTR(d->m_abook);

   195   QList<QContact> rtn;

   196   

   197   QList<QContactLocalId> ids = contactIds(filter, sortOrders,error);

   198   foreach (QContactLocalId id, ids)

   199     rtn << contact(id, QContactFetchHint(), error);

   200   return rtn;

   201 }

   202 

   203 QContact QContactMaemo5Engine::contact(const QContactLocalId& contactId, const QContactFetchHint& fetchHint, QContactManager::Error* error) const

   204 {

   205   Q_UNUSED(fetchHint); //TODO

   206   Q_CHECK_PTR(d->m_abook);

   207   

   208   //NOTE getQContact can't set the displayLabel

   209   QContact *contact = d->m_abook->getQContact(contactId, error);

   210   QContact rtn(*contact);

   211   delete contact;

   212   if (*error == QContactManager::NoError) {

   213     setContactDisplayLabel(&rtn, synthesizedDisplayLabel(rtn, error));

   214     QContactId cid;

   215     cid.setLocalId(contactId);

   216     cid.setManagerUri(managerUri());

   217     rtn.setId(cid);

   218   }

   219   return rtn;

   220 }

   221 

   222 bool QContactMaemo5Engine::saveContacts(QList<QContact>* contacts, QMap<int, QContactManager::Error>* errorMap, QContactManager::Error* error)

   223 {

   224     *error = QContactManager::NoError;

   225     QContactManager::Error tempError = QContactManager::NoError;

   226     QContact curr;

   227     for (int i = 0; i < contacts->size(); i++) {

   228         curr = contacts->at(i);

   229         if (!saveContact(&curr, &tempError)) {

   230             if (errorMap)

   231                 errorMap->insert(i, tempError);

   232             *error = tempError;

   233         } else {

   234             contacts->replace(i, curr);

   235         }

   236     }

   237 

   238     return (*error == QContactManager::NoError);

   239 }

   240 

   241 bool QContactMaemo5Engine::removeContacts(const QList<QContactLocalId>& ids, QMap<int, QContactManager::Error>* errorMap, QContactManager::Error* error)

   242 {

   243     *error = QContactManager::NoError;

   244     QContactManager::Error tempError = QContactManager::NoError;

   245     QContact curr;

   246     for (int i = 0; i < ids.size(); i++) {

   247         if (!removeContact(ids.at(i), &tempError)) {

   248             if (errorMap)

   249                 errorMap->insert(i, tempError);

   250             *error = tempError;

   251         }

   252     }

   253 

   254     return (*error == QContactManager::NoError);

   255 }

   256 

   257 bool QContactMaemo5Engine::saveContact(QContact* contact, QContactManager::Error* error)

   258 {

   259   Q_CHECK_PTR(d->m_abook);

   260   

   261   if (!contact) {

   262     *error = QContactManager::BadArgumentError;

   263     return false;

   264   }

   265 

   266   // synthesize the display label for the contact

   267   setContactDisplayLabel(contact, synthesizedDisplayLabel(*contact, error));

   268 

   269   // ensure that the contact's details conform to their definitions

   270   if (!validateContact(*contact, error)) {

   271     QCM5_DEBUG << "Validate Contact failed";

   272     return false;

   273   }

   274 

   275   bool retn = d->m_abook->saveContact(contact, error);

   276   QContactId cId = contact->id();

   277   cId.setManagerUri(managerUri());

   278   contact->setId(cId);

   279   return retn;

   280 }

   281 

   282 bool QContactMaemo5Engine::removeContact(const QContactLocalId& contactId, QContactManager::Error* error)

   283 {

   284   Q_CHECK_PTR(d->m_abook);

   285   return d->m_abook->removeContact(contactId, error);

   286 }

   287 

   288 QMap<QString, QContactDetailDefinition> QContactMaemo5Engine::detailDefinitions(const QString& contactType, QContactManager::Error* error) const

   289 {

   290 

   291     QMap<QString, QMap<QString, QContactDetailDefinition> > defns = QContactManagerEngine::schemaDefinitions();

   292     

   293     QMap<QString, QContactDetailFieldDefinition> fields;

   294     

   295     QContactDetailFieldDefinition gsfd; //Generic string field definition

   296     gsfd.setDataType(QVariant::String);

   297 

   298     // QContactAddress

   299     fields = defns[contactType][QContactAddress::DefinitionName].fields();

   300     fields.remove(QContactAddress::FieldSubTypes);

   301     fields.insert(AddressFieldExtension, gsfd);

   302     fields.insert(QContactDetail::FieldDetailUri, gsfd);

   303     defns[contactType][QContactAddress::DefinitionName].setFields(fields);

   304     defns[contactType][QContactAddress::DefinitionName].setUnique(false);

   305     

   306     // No QContactAnniversary

   307     defns[contactType].remove(QContactAnniversary::DefinitionName);

   308     

   309     // No QContactAvatar

   310     defns[contactType].remove(QContactAvatar::DefinitionName);

   311 

   312     // QContactBirthday

   313     fields = defns[contactType][QContactBirthday::DefinitionName].fields();

   314     fields.remove(QContactDetail::FieldContext);

   315     defns[contactType][QContactBirthday::DefinitionName].setFields(fields);

   316     defns[contactType][QContactBirthday::DefinitionName].setUnique(true);

   317 

   318     // QContactDisplayLabel

   319     fields = defns[contactType][QContactDisplayLabel::DefinitionName].fields();

   320     defns[contactType][QContactDisplayLabel::DefinitionName].setFields(fields);

   321     defns[contactType][QContactDisplayLabel::DefinitionName].setUnique(true);

   322     

   323     // QContactEmailAddress

   324     fields = defns[contactType][QContactEmailAddress::DefinitionName].fields();

   325     fields.insert(QContactDetail::FieldDetailUri, gsfd);

   326     defns[contactType][QContactEmailAddress::DefinitionName].setFields(fields);

   327     defns[contactType][QContactEmailAddress::DefinitionName].setUnique(false);

   328     

   329     // QContactFamily

   330     fields = defns[contactType][QContactFamily::DefinitionName].fields();

   331     fields.remove(QContactDetail::FieldContext);

   332     defns[contactType][QContactFamily::DefinitionName].setFields(fields);

   333     defns[contactType][QContactFamily::DefinitionName].setUnique(true);

   334 

   335     // QContactGender

   336     fields = defns[contactType][QContactGender::DefinitionName].fields();

   337     fields.remove(QContactDetail::FieldContext);

   338     defns[contactType][QContactGender::DefinitionName].setFields(fields);

   339     defns[contactType][QContactGender::DefinitionName].setUnique(true);

   340 

   341     // No QContactGeoLocation

   342     defns[contactType].remove(QContactGeoLocation::DefinitionName);

   343     

   344     // QContactGuid

   345     fields = defns[contactType][QContactGuid::DefinitionName].fields();

   346     fields.remove(QContactDetail::FieldContext);

   347     defns[contactType][QContactGuid::DefinitionName].setFields(fields);

   348     defns[contactType][QContactGuid::DefinitionName].setUnique(true);

   349   

   350     // No QContactGlobalPresence

   351     defns[contactType].remove(QContactGlobalPresence::DefinitionName);

   352 

   353     // QContactName

   354     fields = defns[contactType][QContactName::DefinitionName].fields();

   355     fields.remove(QContactDetail::FieldContext);

   356     fields.remove(QContactName::FieldCustomLabel);

   357     fields.remove(QContactName::FieldMiddleName);

   358     fields.remove(QContactName::FieldPrefix);

   359     fields.remove(QContactName::FieldSuffix);

   360     defns[contactType][QContactName::DefinitionName].setFields(fields);

   361     defns[contactType][QContactName::DefinitionName].setUnique(true);

   362     

   363     // QContactNickname

   364     fields = defns[contactType][QContactNickname::DefinitionName].fields();

   365     fields.remove(QContactDetail::FieldContext);

   366     defns[contactType][QContactNickname::DefinitionName].setFields(fields);

   367     defns[contactType][QContactNickname::DefinitionName].setUnique(true);

   368 

   369     // QContactNote

   370     fields = defns[contactType][QContactNote::DefinitionName].fields();

   371     fields.remove(QContactDetail::FieldContext);

   372     defns[contactType][QContactNote::DefinitionName].setFields(fields);

   373     defns[contactType][QContactNote::DefinitionName].setUnique(true);

   374 

   375     // QContactOnlineAccount

   376     fields = defns[contactType][QContactOnlineAccount::DefinitionName].fields();

   377     fields.remove(QContactDetail::FieldContext);

   378     fields.remove(QContactOnlineAccount::FieldAccountUri);

   379     fields.remove(QContactOnlineAccount::FieldSubTypes);

   380     fields.insert("AccountPath", gsfd);

   381     defns[contactType][QContactOnlineAccount::DefinitionName].setFields(fields);

   382     defns[contactType][QContactOnlineAccount::DefinitionName].setUnique(false);

   383     

   384     // QContactOrganization

   385     fields = defns[contactType][QContactOrganization::DefinitionName].fields();

   386     fields.remove(QContactDetail::FieldContext);

   387     fields.remove(QContactOrganization::FieldAssistantName);

   388     fields.remove(QContactOrganization::FieldDepartment);

   389     fields.remove(QContactOrganization::FieldLocation);

   390     fields.remove(QContactOrganization::FieldLogoUrl);

   391     fields.remove(QContactOrganization::FieldTitle);

   392     fields.remove(QContactOrganization::FieldRole);

   393     defns[contactType][QContactOrganization::DefinitionName].setFields(fields);

   394     defns[contactType][QContactOrganization::DefinitionName].setUnique(true);

   395     

   396     // QContactPhoneNumber

   397     fields = defns[contactType][QContactPhoneNumber::DefinitionName].fields();

   398     fields.insert(QContactDetail::FieldDetailUri, gsfd);

   399     QContactDetailFieldDefinition phoneSubtype = fields.value(QContactPhoneNumber::FieldSubTypes);

   400     QVariantList allowableValues;

   401     allowableValues << QContactPhoneNumber::SubTypeMobile;

   402     allowableValues << QContactPhoneNumber::SubTypeVoice;

   403     phoneSubtype.setAllowableValues(allowableValues);

   404     fields.insert(QContactPhoneNumber::FieldSubTypes, phoneSubtype);

   405     defns[contactType][QContactPhoneNumber::DefinitionName].setFields(fields);

   406     defns[contactType][QContactPhoneNumber::DefinitionName].setUnique(false);

   407 

   408     // QContactPresence

   409     fields = defns[contactType][QContactPresence::DefinitionName].fields();

   410     fields.remove(QContactPresence::FieldTimestamp);

   411     fields.remove(QContactPresence::FieldPresenceState);

   412     defns[contactType][QContactPresence::DefinitionName].setFields(fields);

   413     defns[contactType][QContactPresence::DefinitionName].setUnique(false);

   414     

   415     // No QContactRingtone

   416     defns[contactType].remove(QContactRingtone::DefinitionName);

   417     

   418     // No QContactSyncTarget

   419     defns[contactType].remove(QContactSyncTarget::DefinitionName);

   420 

   421     // No QContactTag

   422     defns[contactType].remove(QContactTag::DefinitionName);

   423     

   424     // QContactTimestamp

   425     fields = defns[contactType][QContactTimestamp::DefinitionName].fields();

   426     fields.remove(QContactDetail::FieldContext);

   427     defns[contactType][QContactTimestamp::DefinitionName].setFields(fields);

   428     

   429     // QContactType

   430     fields = defns[contactType][QContactType::DefinitionName].fields();

   431     fields.remove(QContactDetail::FieldContext);

   432     defns[contactType][QContactType::DefinitionName].setFields(fields);

   433 

   434     // QContactUrl

   435     fields = defns[contactType][QContactUrl::DefinitionName].fields();

   436     fields.remove(QContactDetail::FieldContext);

   437     fields.remove(QContactUrl::FieldSubType);

   438     defns[contactType][QContactUrl::DefinitionName].setFields(fields);

   439     defns[contactType][QContactUrl::DefinitionName].setUnique(true);

   440     

   441     QCM5_DEBUG << "Contact type" << contactType << "Keys" <<  defns.keys();

   442     

   443     *error = QContactManager::NoError;

   444     return defns[contactType];

   445 }

   446 

   447 QContactDetailDefinition QContactMaemo5Engine::detailDefinition(const QString& definitionName, const QString& contactType, QContactManager::Error* error) const

   448 {

   449     return QContactManagerEngine::detailDefinition(definitionName, contactType, error);

   450 }

   451 

   452 bool QContactMaemo5Engine::hasFeature(QContactManager::ManagerFeature feature, const QString& contactType) const {

   453   Q_UNUSED(contactType);

   454   if (feature == QContactManager::Anonymous)

   455     return true;

   456   

   457   return false;

   458 }

   459 

   460 bool QContactMaemo5Engine::isFilterSupported(const QContactFilter& filter) const {

   461   switch (filter.type()) {

   462     case QContactFilter::InvalidFilter:

   463     case QContactFilter::DefaultFilter:

   464     case QContactFilter::LocalIdFilter:

   465     case QContactFilter::ContactDetailFilter:

   466     case QContactFilter::ActionFilter:

   467     case QContactFilter::IntersectionFilter:

   468     case QContactFilter::UnionFilter:

   469       return true;

   470     default:

   471       return false;

   472   }

   473 }

   474 

   475 QList<QVariant::Type> QContactMaemo5Engine::supportedDataTypes() const {

   476   QList<QVariant::Type> st;

   477   st.append(QVariant::String);

   478   st.append(QVariant::Int);

   479   st.append(QVariant::UInt);

   480   st.append(QVariant::Double);

   481   st.append(QVariant::Date);

   482   st.append(QVariant::DateTime);

   483 

   484   return st;   

   485 }

   486 

   487 void QContactMaemo5Engine::requestDestroyed(QContactAbstractRequest* req){

   488   m_asynchronousOperations.removeOne(req);

   489 }

   490 

   491 bool QContactMaemo5Engine::startRequest(QContactAbstractRequest* req){

   492   if (!m_asynchronousOperations.contains(req))

   493     m_asynchronousOperations.enqueue(req);

   494   updateRequestState(req, QContactAbstractRequest::ActiveState);

   495   QTimer::singleShot(0, this, SLOT(performAsynchronousOperation()));

   496   return true;

   497 }

   498 

   499 bool QContactMaemo5Engine::cancelRequest(QContactAbstractRequest* req){

   500   updateRequestState(req, QContactAbstractRequest::CanceledState);

   501   return true;

   502 }

   503 

   504 bool QContactMaemo5Engine::waitForRequestProgress(QContactAbstractRequest* req, int msecs){

   505   Q_UNUSED(msecs);

   506   

   507   if (!m_asynchronousOperations.removeOne(req))

   508     return false; // didn't exist.

   509 

   510   // replace at head of queue

   511   m_asynchronousOperations.insert(0, req);

   512 

   513   // and perform the operation.

   514   performAsynchronousOperation();

   515 

   516   return true;

   517 }

   518 

   519 bool QContactMaemo5Engine::waitForRequestFinished(QContactAbstractRequest* req, int msecs){

   520   // in our implementation, we always complete any operation we start.

   521   // so, waitForRequestFinished is equivalent to waitForRequestProgress.

   522   return waitForRequestProgress(req, msecs);

   523 }

   524 

   525 void QContactMaemo5Engine::performAsynchronousOperation(){

   526   QContactAbstractRequest *currentRequest;

   527 

   528   // take the first pending request and finish it

   529   if (m_asynchronousOperations.isEmpty())

   530     return;

   531   currentRequest = m_asynchronousOperations.dequeue();

   532 

   533   // check to see if it is cancelling; if so, remove it from the queue and return.

   534   if (currentRequest->state() == QContactAbstractRequest::CanceledState)

   535     return;

   536 

   537   // Now perform the active request and emit required signals.

   538   Q_ASSERT(currentRequest->state() == QContactAbstractRequest::ActiveState);

   539   switch (currentRequest->type()) {

   540     case QContactAbstractRequest::ContactFetchRequest:

   541     {

   542       QContactFetchRequest* r = static_cast<QContactFetchRequest*>(currentRequest);

   543       QContactFilter filter = r->filter();

   544       QList<QContactSortOrder> sorting = r->sorting();

   545       QContactFetchHint fh = r->fetchHint();

   546 

   547       QContactManager::Error operationError;

   548       QList<QContact> requestedContacts = contacts(filter, sorting, fh, &operationError);

   549 

   550       // update the request with the results.

   551       updateContactFetchRequest(r, requestedContacts, operationError, QContactAbstractRequest::FinishedState); // emit resultsAvailable()

   552     } break;

   553     case QContactAbstractRequest::ContactLocalIdFetchRequest:

   554     {

   555       QContactLocalIdFetchRequest* r = static_cast<QContactLocalIdFetchRequest*>(currentRequest);

   556       QContactFilter filter = r->filter();

   557       QList<QContactSortOrder> sorting = r->sorting();

   558 

   559       QContactManager::Error operationError = QContactManager::NoError;

   560       QList<QContactLocalId> requestedContactIds = contactIds(filter, sorting, &operationError);

   561 

   562       updateContactLocalIdFetchRequest(r, requestedContactIds, operationError, QContactAbstractRequest::FinishedState);

   563     } break;

   564     case QContactAbstractRequest::ContactSaveRequest:

   565     {

   566       QContactSaveRequest* r = static_cast<QContactSaveRequest*>(currentRequest);

   567       QList<QContact> contacts = r->contacts();

   568 

   569       QContactManager::Error operationError = QContactManager::NoError;

   570       QMap<int, QContactManager::Error> errorMap;

   571       saveContacts(&contacts, &errorMap, &operationError);

   572 

   573       updateContactSaveRequest(r, contacts, operationError, errorMap, QContactAbstractRequest::FinishedState); // there will always be results of some form.  emit resultsAvailable().

   574      } break;

   575      case QContactAbstractRequest::ContactRemoveRequest:

   576      {

   577        // this implementation provides scant information to the user

   578        // the operation either succeeds (all contacts matching the filter were removed)

   579        // or it fails (one or more contacts matching the filter could not be removed)

   580        // if a failure occurred, the request error will be set to the most recent

   581        // error that occurred during the remove operation.

   582        QContactRemoveRequest* r = static_cast<QContactRemoveRequest*>(currentRequest);

   583        QContactManager::Error operationError = QContactManager::NoError;

   584        QList<QContactLocalId> contactsToRemove = r->contactIds();

   585        QMap<int, QContactManager::Error> errorMap;

   586 

   587        for (int i = 0; i < contactsToRemove.size(); i++) {

   588          QContactManager::Error tempError;

   589          removeContact(contactsToRemove.at(i), /*changeSet,*/ &tempError);

   590 

   591          errorMap.insert(i, tempError);                

   592          if (tempError != QContactManager::NoError) {

   593            operationError = tempError;

   594          }

   595        }

   596 

   597        updateContactRemoveRequest(r, operationError, errorMap, QContactAbstractRequest::FinishedState);

   598      } break;

   599      case QContactAbstractRequest::DetailDefinitionFetchRequest:

   600      {

   601        QContactDetailDefinitionFetchRequest* r = static_cast<QContactDetailDefinitionFetchRequest*>(currentRequest);

   602        QContactManager::Error operationError = QContactManager::NoError;

   603        QMap<int, QContactManager::Error> errorMap;

   604        QMap<QString, QContactDetailDefinition> requestedDefinitions;

   605        QStringList names = r->definitionNames();

   606        if (names.isEmpty())

   607          names = detailDefinitions(r->contactType(), &operationError).keys(); // all definitions.

   608 

   609        QContactManager::Error tempError;

   610        for (int i = 0; i < names.size(); i++) {

   611          QContactDetailDefinition current = detailDefinition(names.at(i), r->contactType(), &tempError);

   612          requestedDefinitions.insert(names.at(i), current);

   613 

   614          errorMap.insert(i, tempError);              

   615          if (tempError != QContactManager::NoError) {

   616            operationError = tempError;

   617          }

   618        }

   619 

   620        updateDefinitionFetchRequest(r, requestedDefinitions, operationError, errorMap, QContactAbstractRequest::FinishedState);

   621      } break;

   622      default:

   623      {

   624        // this engine currently does not support mutable definitions.

   625      } break;

   626 

   627     

   628   } 

   629 }

   630