58 #include <qtrackerrelationshipfetchrequest.h>

    58 #include <qtrackerrelationshipfetchrequest.h>

    59 #include <qtrackerrelationshipsaverequest.h>

    59 #include <qtrackerrelationshipsaverequest.h>

    60 #include <qtrackercontactidfetchrequest.h>

    60 #include <qtrackercontactidfetchrequest.h>

    61 

    61 

    62 

    62 

    64 {

    64 {

    65     Q_UNUSED(error);

    65     Q_UNUSED(error);

    67 }

    68 }

    68 

    69 

    69 QString ContactTrackerFactory::managerName() const

    70 QString ContactTrackerFactory::managerName() const

    70 {

    71 {

    71     return QString("tracker");

    72     return QString("tracker");

    99     connectToSignals();

   100     connectToSignals();

   100 }

   101 }

   101 

   102 

   102 void QContactTrackerEngine::connectToSignals()

   103 void QContactTrackerEngine::connectToSignals()

   103 {

   104 {

   105     connect(listener, SIGNAL(contactsAdded(const QList<QContactLocalId>&)), SIGNAL(contactsAdded(const QList<QContactLocalId>&)));

   106     connect(listener, SIGNAL(contactsAdded(const QList<QContactLocalId>&)), SIGNAL(contactsAdded(const QList<QContactLocalId>&)));

   106     connect(listener, SIGNAL(contactsChanged(const QList<QContactLocalId>&)), SIGNAL(contactsChanged(const QList<QContactLocalId>&)));

   107     connect(listener, SIGNAL(contactsChanged(const QList<QContactLocalId>&)), SIGNAL(contactsChanged(const QList<QContactLocalId>&)));

   107     connect(listener, SIGNAL(contactsRemoved(const QList<QContactLocalId>&)), SIGNAL(contactsRemoved(const QList<QContactLocalId>&)));

   108     connect(listener, SIGNAL(contactsRemoved(const QList<QContactLocalId>&)), SIGNAL(contactsRemoved(const QList<QContactLocalId>&)));

   108 }

   109 }

   109 

   110 

   128 {

   129 {

   129     if (!d->m_refCount.deref())

   130     if (!d->m_refCount.deref())

   130         delete this;

   131         delete this;

   131 }

   132 }

   132 

   133 

   134 {

   135 {

   135     return contactIds(QContactFilter(), sortOrders, error);

   136     return contactIds(QContactFilter(), sortOrders, error);

   136 }

   137 }

   137 

   138 

   139 {

   140 {

   140     QContactLocalIdFetchRequest request;

   141     QContactLocalIdFetchRequest request;

   141     request.setFilter(filter);

   142     request.setFilter(filter);

   142     request.setSorting(sortOrders);

   143     request.setSorting(sortOrders);

   143 

   144 

   144     QContactTrackerEngine engine(*this);

   145     QContactTrackerEngine engine(*this);

   145     engine.startRequest(&request);

   146     engine.startRequest(&request);

   146     // 10 seconds should be enough

   147     // 10 seconds should be enough

   147     engine.waitForRequestFinished(&request, 10000);

   148     engine.waitForRequestFinished(&request, 10000);

   148     if(!request.isFinished()) {

   149     if(!request.isFinished()) {

   150     }

   151     }

   151     else {

   152     else {

   152         // leave the code for now while not all other code is fixed

   153         // leave the code for now while not all other code is fixed

   154     }

   155     }

   155     return request.ids();

   156     return request.ids();

   156 }

   157 }

   157 

   158 

   164 {

   160 {

   165     // the rest of the code is for internal usage, unit tests etc.

   161     // the rest of the code is for internal usage, unit tests etc.

   166     QContactFetchRequest request;

   162     QContactFetchRequest request;

   168     request.setFilter(filter);

   164     request.setFilter(filter);

   169     request.setSorting(sortOrders);

   165     request.setSorting(sortOrders);

   170 

   166 

   171     QContactTrackerEngine engine(*this);

   167     QContactTrackerEngine engine(*this);

   172     engine.startRequest(&request);

   168     engine.startRequest(&request);

   173     // 10 seconds should be enough

   169     // 10 seconds should be enough

   174     engine.waitForRequestFinished(&request, 10000);

   170     engine.waitForRequestFinished(&request, 10000);

   175 

   171 

   176     if( !request.isFinished()) {

   172     if( !request.isFinished()) {

   178     }

   174     }

   179     else {

   175     else {

   180         // leave the code for now while not all other code is fixed

   176         // leave the code for now while not all other code is fixed

   182     }

   178     }

   183     return request.contacts();

   179     return request.contacts();

   184 }

   180 }

   185 

   181 

   191 // used in tests, removed warning while decided if to provide sync api. Until then customers are advised to use async

   196 // used in tests, removed warning while decided if to provide sync api. Until then customers are advised to use async

   195     QContactLocalIdFilter idlist;

   199     QContactLocalIdFilter idlist;

   196     QList<QContactLocalId> ids; ids << contactId;

   200     QList<QContactLocalId> ids; ids << contactId;

   197     idlist.setIds(ids);

   201     idlist.setIds(ids);

   198     QContactFetchRequest request;

   202     QContactFetchRequest request;

   215     request.setFilter(idlist);

   224     request.setFilter(idlist);

   216 

   225 

   217     QContactTrackerEngine engine(*this);

   226     QContactTrackerEngine engine(*this);

   218     engine.startRequest(&request);

   227     engine.startRequest(&request);

   219     // 10 seconds should be enough

   228     // 10 seconds should be enough

   220     engine.waitForRequestFinished(&request, 10000);

   229     engine.waitForRequestFinished(&request, 10000);

   221 

   230 

   222     if( !request.isFinished()) {

   231     if( !request.isFinished()) {

   224         return QContact();

   233         return QContact();

   225     }

   234     }

   226     else if(request.contacts().size() == 0)

   235     else if(request.contacts().size() == 0)

   227     {

   236     {

   229         return QContact();

   238         return QContact();

   230     }

   239     }

   231     else {

   240     else {

   232         // leave the code for now while not all other code is fixed

   241         // leave the code for now while not all other code is fixed

   234         return request.contacts()[0];

   243         return request.contacts()[0];

   235     }

   244     }

   236 

   245 

   237 }

   246 }

   238 

   247 

   255     qDebug() << Q_FUNC_INFO <<"Status Finished" << req->isFinished();

   264     qDebug() << Q_FUNC_INFO <<"Status Finished" << req->isFinished();

   256     return req->isFinished();

   265     return req->isFinished();

   257 

   266 

   258 }

   267 }

   259 

   268 

   261 {

   270 {

   262     // Signal emitted from TrackerChangeListener

   271     // Signal emitted from TrackerChangeListener

   263     QContactSaveRequest request;

   272     QContactSaveRequest request;

   264     QList<QContact> contacts(QList<QContact>()<<*contact);

   273     QList<QContact> contacts(QList<QContact>()<<*contact);

   265     request.setContacts(contacts);

   274     request.setContacts(contacts);

   266     QContactTrackerEngine engine(*this);

   275     QContactTrackerEngine engine(*this);

   267     engine.startRequest(&request);

   276     engine.startRequest(&request);

   268     // 10 seconds should be enough

   277     // 10 seconds should be enough

   269     engine.waitForRequestFinished(&request, 10000);

   278     engine.waitForRequestFinished(&request, 10000);

   271     Q_ASSERT(request.contacts().size() == 1);

   280     Q_ASSERT(request.contacts().size() == 1);

   272     *contact = request.contacts()[0];

   281     *contact = request.contacts()[0];

   273 

   282 

   275         return true;

   284         return true;

   276     else

   285     else

   277         return false;

   286         return false;

   278 }

   287 }

   279 

   288 

   283 

   292 

   284     // TODO: Do with LiveNodes when they support strict querying.

   293     // TODO: Do with LiveNodes when they support strict querying.

   285     RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();

   294     RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();

   286     RDFContact.property<nco::contactUID>() = LiteralValue(QString::number(contactId));

   295     RDFContact.property<nco::contactUID>() = LiteralValue(QString::number(contactId));

   287     RDFSelect query;

   296     RDFSelect query;

   288 

   297 

   289     query.addColumn("contact_uri", RDFContact);

   298     query.addColumn("contact_uri", RDFContact);

   290     LiveNodes ncoContacts = ::tracker()->modelQuery(query);

   299     LiveNodes ncoContacts = ::tracker()->modelQuery(query);

   291     if(ncoContacts->rowCount() == 0) {

   300     if(ncoContacts->rowCount() == 0) {

   293         return false;

   302         return false;

   294     }

   303     }

   295 

   304 

   296 

   305 

   297     Live< nco::PersonContact> ncoContact = ncoContacts->liveNode(0);

   306     Live< nco::PersonContact> ncoContact = ncoContacts->liveNode(0);

   307     emit contactsRemoved(removed);

   316     emit contactsRemoved(removed);

   308 

   317 

   309     return true;

   318     return true;

   310 }

   319 }

   311 

   320 

   313 {

   322 {

   314     // @todo: Handle errors per saved contact.

   323     // @todo: Handle errors per saved contact.

   315     Q_UNUSED(errorMap)

   324     Q_UNUSED(errorMap)

   316 

   325 

   318 

   327 

   319     if(contacts == 0) {

   328     if(contacts == 0) {

   321         return false;

   330         return false;

   322     }

   331     }

   323 

   332 

   324     // Signal emitted from TrackerChangeListener

   333     // Signal emitted from TrackerChangeListener

   325     QContactSaveRequest request;

   334     QContactSaveRequest request;

   334     engine.waitForRequestFinished(&request, 1000*contacts->size());

   343     engine.waitForRequestFinished(&request, 1000*contacts->size());

   335     /// @todo what should we do in case request.isFinished() == false

   344     /// @todo what should we do in case request.isFinished() == false

   336     if (request.isFinished() == false) {

   345     if (request.isFinished() == false) {

   337         qWarning() << "QContactTrackerEngine::saveContacts:" << "request not finished";

   346         qWarning() << "QContactTrackerEngine::saveContacts:" << "request not finished";

   338     }

   347     }

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

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

   341         (*contacts)[i] = request.contacts().at(i);

   350         (*contacts)[i] = request.contacts().at(i);

   342     }

   351     }

   343 

   352 

   344     // Returns false if we have any errors - true if everything went ok.

   353     // Returns false if we have any errors - true if everything went ok.

   349 {

   358 {

   350     // Cannot report errors - giving up.

   359     // Cannot report errors - giving up.

   351     if(!errorMap) {

   360     if(!errorMap) {

   353         return false;

   362         return false;

   354     }

   363     }

   355 

   364 

   356     // let's clear the error hash so there is nothing old haunting us.

   365     // let's clear the error hash so there is nothing old haunting us.

   357     errorMap->clear();

   366     errorMap->clear();

   358 

   367 

   365         QContactManager::Error lastError;

   369         QContactManager::Error lastError;

   371             errorMap->insert(i, lastError);

   372             errorMap->insert(i, lastError);

   372         }

   373         }

   373     }

   374     }

   374 

   375 

   375     // Returns true if no errors were encountered - false if there was errors.

   376     // Returns true if no errors were encountered - false if there was errors.

   376     // emit signals removed as they are fired from QContactManager

   377     // emit signals removed as they are fired from QContactManager

   377     return (errorMap->isEmpty());

   378     return (errorMap->isEmpty());

   378 }

   379 }

   379 

   380 

   380 QMap<QString, QContactDetailDefinition> QContactTrackerEngine::detailDefinitions(const QString& contactType,

   381 QMap<QString, QContactDetailDefinition> QContactTrackerEngine::detailDefinitions(const QString& contactType,

   382 {

   383 {

   383     if (contactType != QContactType::TypeContact) {

   384     if (contactType != QContactType::TypeContact) {

   385         return QMap<QString, QContactDetailDefinition>();

   386         return QMap<QString, QContactDetailDefinition>();

   386     }

   387     }

   387 

   388 

   388     // lazy initialisation of schema definitions.

   389     // lazy initialisation of schema definitions.

   389     if (d->m_definitions.isEmpty()) {

   390     if (d->m_definitions.isEmpty()) {

   390         // none in the list?  get the schema definitions, and modify them to match our capabilities.

   391         // none in the list?  get the schema definitions, and modify them to match our capabilities.

   391         d->m_definitions = QContactManagerEngine::schemaDefinitions().value(QContactType::TypeContact);

   392         d->m_definitions = QContactManagerEngine::schemaDefinitions().value(QContactType::TypeContact);

   400         // modification: name is unique

   394         // modification: name is unique

   401         QContactDetailDefinition nameDef = d->m_definitions.value(QContactName::DefinitionName);

   395         QContactDetailDefinition nameDef = d->m_definitions.value(QContactName::DefinitionName);

   402         nameDef.setUnique(true);

   396         nameDef.setUnique(true);

   403         d->m_definitions.insert(QContactName::DefinitionName, nameDef);

   397         d->m_definitions.insert(QContactName::DefinitionName, nameDef);

   404 

   398 

   424             subTypes << QString(QLatin1String(QContactUrl::SubTypeHomePage));

   418             subTypes << QString(QLatin1String(QContactUrl::SubTypeHomePage));

   425             f.setAllowableValues(subTypes);

   419             f.setAllowableValues(subTypes);

   426             fields.insert(QContactUrl::FieldSubType, f);

   420             fields.insert(QContactUrl::FieldSubType, f);

   427             newUrlDef.setFields(fields);

   421             newUrlDef.setFields(fields);

   428             newUrlDef.setUnique(true);

   422             newUrlDef.setUnique(true);

   429             d->m_definitions.insert(QContactUrl::DefinitionName, newUrlDef);

   424             d->m_definitions.insert(QContactUrl::DefinitionName, newUrlDef);

   430         }

   425         }

   431 

   426 

   432         // QContactOnlineAccount custom fields

   427         // QContactOnlineAccount custom fields

   433         {

   428         {

   440 

   435 

   441             f.setDataType(QVariant::String);

   436             f.setDataType(QVariant::String);

   442             fields.insert("Account", f);

   437             fields.insert("Account", f);

   443             fields.insert("AccountPath", f);

   438             fields.insert("AccountPath", f);

   444             newAccountDefinition.setFields(fields);

   439             newAccountDefinition.setFields(fields);

   445             d->m_definitions.insert(QContactOnlineAccount::DefinitionName, newAccountDefinition);

   441             d->m_definitions.insert(QContactOnlineAccount::DefinitionName, newAccountDefinition);

   446         }

   442         }

   452     return d->m_definitions;

   446     return d->m_definitions;

   453 }

   447 }

   454 

   448 

   455 /*!

   449 /*!

   456  * \reimp

   450  * \reimp

   457  */

   451  */

   460     switch (feature) {

   458     switch (feature) {

   461         case QContactManager::Groups:

   459         case QContactManager::Groups:

   462         case QContactManager::ActionPreferences:

   460         case QContactManager::ActionPreferences:

   463         case QContactManager::Relationships:

   461         case QContactManager::Relationships:

   464             return true;

   463             return true;

   465         case QContactManager::ArbitraryRelationshipTypes:

   464         case QContactManager::ArbitraryRelationshipTypes:

   466             return true;

   465             return true;

   467         case QContactManager::MutableDefinitions:

   466         case QContactManager::MutableDefinitions:

   468             return true;

   467             return true;

   479  */

   478  */

   480 /*!

   479 /*!

   481  * Definition identifiers which are natively (fast) filterable

   480  * Definition identifiers which are natively (fast) filterable

   482  * on the default backend store managed by the manager from which the capabilities object was accessed

   481  * on the default backend store managed by the manager from which the capabilities object was accessed

   483  */

   482  */

   485 {

   484 {

   486     switch (filter.type()) {

   485     switch (filter.type()) {

   487         case QContactFilter::InvalidFilter:

   486         case QContactFilter::InvalidFilter:

   488         case QContactFilter::DefaultFilter:

   487         case QContactFilter::DefaultFilter:

   489         case QContactFilter::LocalIdFilter:

   488         case QContactFilter::LocalIdFilter:

   522 {

   521 {

   523     return d->m_engineName;

   522     return d->m_engineName;

   524 }

   523 }

   525 

   524 

   526 /*!

   525 /*!

   528  */

   527  */

   530 {

   529 {

   531     return d->m_engineVersion;

   530     return d->m_engineVersion;

   532 }

   531 }

   533 

   532 

   534 RDFVariable QContactTrackerEngine::contactDetail2Rdf(const RDFVariable& rdfContact, const QString& definitionName,

   533 RDFVariable QContactTrackerEngine::contactDetail2Rdf(const RDFVariable& rdfContact, const QString& definitionName,

   535                                                       const QString& fieldName) const

   534                                                       const QString& fieldName) const

   536 {

   535 {

   537     if (definitionName == QContactName::DefinitionName) {

   536     if (definitionName == QContactName::DefinitionName) {

   539             return rdfContact.property<nco::nameGiven>();

   538             return rdfContact.property<nco::nameGiven>();

   540         }

   539         }

   542             return rdfContact.property<nco::nameFamily>();

   541             return rdfContact.property<nco::nameFamily>();

   543         }

   542         }

   545             return rdfContact.property<nco::nameAdditional>();

   544             return rdfContact.property<nco::nameAdditional>();

   546         }

   545         }

   547         else if (fieldName == QContactName::FieldPrefix) {

   546         else if (fieldName == QContactName::FieldPrefix) {

   548             return rdfContact.property<nco::nameHonorificPrefix>();

   547             return rdfContact.property<nco::nameHonorificPrefix>();

   549         }

   548         }

   594     d->m_requests[req] = request;

   593     d->m_requests[req] = request;

   595     return true;

   594     return true;

   596 }

   595 }

   597 

   596 

   598 /*! \reimp */

   597 /*! \reimp */

   600 {

   599 {

   601     QString label = QContactManagerEngine::synthesizedDisplayLabel(contact, error);

   600     QString label = QContactManagerEngine::synthesizedDisplayLabel(contact, error);

   602     if (label.isEmpty())

   601     if (label.isEmpty())

   603         label = contact.detail<QContactNickname>().nickname();

   602         label = contact.detail<QContactNickname>().nickname();

   606     return label;

   608     return label;

   607 }

   609 }