|
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 |