45 #include <QTimer>

   129 }

   130 

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

   132 {

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

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

   274     fields.remove(QContactDetail::FieldContext);

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

   276 

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

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

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

   288     fields.remove(QContactDetail::FieldContext);

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

   290 

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

   301     fields.remove(QContactDetail::FieldContext);

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

   303   

   304     // No QContactGlobalPresence

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

   306 

   309     fields.remove(QContactDetail::FieldContext);

   311     fields.remove(QContactName::FieldMiddleName);

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

   318     fields.remove(QContactDetail::FieldContext);

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

   320 

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

   323     fields.remove(QContactDetail::FieldContext);

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

   325 

   328     fields.remove(QContactDetail::FieldContext);

   336     fields.remove(QContactDetail::FieldContext);

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

   349     QVariantList allowableValues;

   350     allowableValues << QContactPhoneNumber::SubTypeMobile;

   351     allowableValues << QContactPhoneNumber::SubTypeVoice;

   352     phoneSubtype.setAllowableValues(allowableValues);

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

   364 

   365     // No QContactTag

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

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

   370     fields.remove(QContactDetail::FieldContext);

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

   372 

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

   375     fields.remove(QContactDetail::FieldContext);

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

   377 

   380     fields.remove(QContactDetail::FieldContext);

   429 

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

   431   m_asynchronousOperations.removeOne(req);

   432 }

   433 

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

   435   if (!m_asynchronousOperations.contains(req))

   436     m_asynchronousOperations.enqueue(req);

   437   updateRequestState(req, QContactAbstractRequest::ActiveState);

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

   439   return true;

   440 }

   441 

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

   443   updateRequestState(req, QContactAbstractRequest::CanceledState);

   444   return true;

   445 }

   446 

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

   448   Q_UNUSED(msecs);

   449   

   450   if (!m_asynchronousOperations.removeOne(req))

   451     return false; // didn't exist.

   452 

   453   // replace at head of queue

   454   m_asynchronousOperations.insert(0, req);

   455 

   456   // and perform the operation.

   457   performAsynchronousOperation();

   458 

   459   return true;

   460 }

   461 

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

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

   464   // so, waitForRequestFinished is equivalent to waitForRequestProgress.

   465   return waitForRequestProgress(req, msecs);

   466 }

   467 

   468 void QContactMaemo5Engine::performAsynchronousOperation(){

   469   QContactAbstractRequest *currentRequest;

   470 

   471   // take the first pending request and finish it

   472   if (m_asynchronousOperations.isEmpty())

   473     return;

   474   currentRequest = m_asynchronousOperations.dequeue();

   475 

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

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

   478     return;

   479 

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

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

   482   switch (currentRequest->type()) {

   483     case QContactAbstractRequest::ContactFetchRequest:

   484     {

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

   486       QContactFilter filter = r->filter();

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

   488       QContactFetchHint fh = r->fetchHint();

   489 

   490       QContactManager::Error operationError;

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

   492 

   493       // update the request with the results.

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

   495     } break;

   496     case QContactAbstractRequest::ContactLocalIdFetchRequest:

   497     {

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

   499       QContactFilter filter = r->filter();

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

   501 

   502       QContactManager::Error operationError = QContactManager::NoError;

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

   504 

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

   506     } break;

   507     case QContactAbstractRequest::ContactSaveRequest:

   508     {

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

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

   511 

   512       QContactManager::Error operationError = QContactManager::NoError;

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

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

   515 

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

   517      } break;

   518      case QContactAbstractRequest::ContactRemoveRequest:

   519      {

   520        // this implementation provides scant information to the user

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

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

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

   524        // error that occurred during the remove operation.

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

   526        QContactManager::Error operationError = QContactManager::NoError;

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

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

   529 

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

   531          QContactManager::Error tempError;

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

   533 

   534          errorMap.insert(i, tempError);                

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

   536            operationError = tempError;

   537          }

   538        }

   539 

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

   541      } break;

   542      case QContactAbstractRequest::DetailDefinitionFetchRequest:

   543      {

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

   545        QContactManager::Error operationError = QContactManager::NoError;

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

   547        QMap<QString, QContactDetailDefinition> requestedDefinitions;

   548        QStringList names = r->definitionNames();

   549        if (names.isEmpty())

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

   551 

   552        QContactManager::Error tempError;

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

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

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

   556 

   557          errorMap.insert(i, tempError);              

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

   559            operationError = tempError;

   560          }

   561        }

   562 

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

   564      } break;

   565      default:

   566      {

   567        // symbian engine currently does not support mutable definitions.

   568      } break;

   569 

   570     

   571   } 

   572 }

   573