FCL/sf/app/contacts: comparison phonebookengines/cntlistmodel/src/cntcache.cpp

equal deleted inserted replaced

-:b46a585f6909
+:efe85016a067
 */
 #include <hbapplication.h>
 #include <qtcontacts.h>
 #include <qcontactmanager.h>
+#include <cntdebug.h>
 #include "cntcache.h"
 #include "cntcache_p.h"
 #include "cntinfoprovider.h"
 // set the singleton instance pointer to NULL
 mWorker(new CntCacheThread()),
 mNextInfoCacheOrder(CacheOrderStartValue),
 mNextIconCacheOrder(CacheOrderStartValue),
 mEmittedContactId(-1)
 {
-DP_IN("CntCache::CntCache()");
+CNT_ENTRY
 // listen to worker updates
 connect(mWorker, SIGNAL(infoFieldUpdated(int, const ContactInfoField&, const QString&)),
 this, SLOT(onNewInfo(int, const ContactInfoField&, const QString&)));
 connect(mWorker, SIGNAL(iconUpdated(const QString&, const HbIcon&)),
 connect(mWorker, SIGNAL(infoCancelled(int)), this, SLOT(onInfoCancelled(int)));
 connect(mWorker, SIGNAL(iconCancelled(const QString&)), this, SLOT(onIconCancelled(const QString&)));
 connect(mWorker, SIGNAL(allJobsDone()), this, SLOT(scheduleOneReadAheadItem()));
 // listen to the database for changes to contacts
-connect(mContactManager, SIGNAL(contactsChanged(const QList<QContactLocalId>&)), this, SLOT(removeContactsFromCache(const QList<QContactLocalId>&)));
+connect(mContactManager, SIGNAL(contactsChanged(const QList<QContactLocalId>&)), this, SLOT(updateContactsInCache(const QList<QContactLocalId>&)));
 connect(mContactManager, SIGNAL(contactsRemoved(const QList<QContactLocalId>&)), this, SLOT(removeContactsFromCache(const QList<QContactLocalId>&)));
 // shutdown only when the whole application shuts down
 connect(HbApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(onShutdown()));
-DP_OUT("CntCache::CntCache()");
+CNT_EXIT
 }
 /*!
 Destructs the CntCache singleton instance.
 */
 CntCache::~CntCache()
 {
-DP_IN("CntCache::~CntCache()");
+CNT_ENTRY
 delete mWorker;
 delete mContactManager;
-DP_OUT("CntCache::~CntCache()");
+qDeleteAll(mInfoCache);
+mInfoCache.clear();
+qDeleteAll(mIconCache);
+mIconCache.clear();
+mInstance = NULL;
+CNT_EXIT
 }
 /*!
 Fetches information about a contact: name, text (e.g. phone number or
 social status) and two icons (e.g. avatar, presence). Previously cached
 \param idList a list with all the IDs in the list
 \return a contact with some details filled in
 */
 CntContactInfo CntCache::fetchContactInfo(int row, const QList<QContactLocalId>& idList)
 {
-DP_IN("CntCache::fetchContactInfo(" << row << ", idlist[" << idList.count() << "])");
+CNT_ENTRY_ARGS(row << "/" << idList.count())
 Q_ASSERT(row >= 0 && row < idList.count());
 QString name;
 QString text = EmptyTextField;
 // ask the worker thread to fetch the information asynchronously
 mWorker->scheduleInfoJob(contactId);
 }
 }
-// cache read-ahead -- items near this fetched item should also be in cache
+CNT_EXIT_ARGS("name:" << name << "sec:" << text)
-// updateReadAhead(row, idList);
-DP_OUT("CntCache::fetchContactInfo(" << row << ", idlist[" << idList.count() << "]) : name =" << name);
 return CntContactInfo(contactId, name, text, icons[0], icons[1]);
 }
 /*!
-Clears the cache - both names and icons. This function can be useful
+Clears the cache of names (not icons). This function can be useful
-for example if application goes to the background and memory needs to
+for example when the format of contact names changes.
-be freed, or if the format of contact names change.
 */
 void CntCache::clearCache()
 {
-DP_IN("CntCache::clearCache()");
+CNT_ENTRY
 // clear info cache
-foreach (CntInfoCacheItem* item, mInfoCache) {
+qDeleteAll(mInfoCache);
-delete item;
-}
 mInfoCache.clear();
 mNextInfoCacheOrder = CacheOrderStartValue;
-// clear icon cache
+CNT_EXIT
-foreach (CntIconCacheItem* item, mIconCache) {
-delete item;
-}
-mIconCache.clear();
-mNextIconCacheOrder = CacheOrderStartValue;
-DP_OUT("CntCache::clearCache()");
 }
 /*!
 Processes a new info field that has arrived from the worker thread.
 If the contact is in the info cache, then the info cache is updated
 is if the info is the name of an icon and that icon is not in the icon
 cache. In this case the icon is fetched before a signal is emitted.
 */
 void CntCache::onNewInfo(int contactId, const ContactInfoField& infoField, const QString& infoValue)
 {
-DP_IN("CntCache::onNewInfo(" << contactId << "," << infoField << "," << infoValue << ")");
+CNT_ENTRY_ARGS( "id:" << contactId   << "infotype:" << infoField   << "infovalue:" << infoValue )
 Q_ASSERT(infoField == ContactInfoTextField || infoField == ContactInfoIcon1Field || infoField == ContactInfoIcon2Field);
 bool hasNewInfo;
 }
 else {
 hasNewInfo = true;
 }
 }
+else if (iconName.startsWith("qtg_", Qt::CaseInsensitive)) {
+CntIconCacheItem* iconItem = createIconCacheItem(iconName);
+onNewIcon(iconName, HbIcon(iconName));
+hasNewInfo = true;
+}
 else {
 CntIconCacheItem* iconItem = createIconCacheItem(iconName);
 iconItem->contactIds.insert(contactId);
 mWorker->scheduleIconJob(iconName);
 hasNewInfo = false;
 }
 }
 else {
 hasNewInfo = false;
 }
 }
 if (hasNewInfo) {
-DP("CntCache::onNewInfo() : new info => emitting contactInfoUpdated(" << contactId << ")");
 emitContactInfoUpdated(contactId);
 }
-DP_OUT("CntCache::onNewInfo(" << contactId << "," << infoField << "," << infoValue << ")");
+CNT_EXIT
 }
 /*!
 Handle the case where a request for contact info is cancelled by the
 worker because of too many subsequent requests.
 */
 void CntCache::onInfoCancelled(int contactId)
 {
-DP_IN("CntCache::onInfoCancelled(" << contactId << ")");
+CNT_ENTRY_ARGS( "id:" << contactId )
 if (mInfoCache.contains(contactId)) {
 CntInfoCacheItem* item = mInfoCache.take(contactId);
 delete item;
 }
-DP("CntCache::onInfoCancelled() : info cancelled => emitting contactInfoUpdated(" << contactId << ")");
 emitContactInfoUpdated(contactId);
-DP_OUT("CntCache::onInfoCancelled(" << contactId << ")");
+CNT_EXIT
 }
 /*!
 Processes a new icon that has arrived from the worker thread.
 The icon cache is updated and a contactInfoUpdated() signal is
 emitted for all contacts that use this icon.
 */
 void CntCache::onNewIcon(const QString& iconName, const HbIcon& icon)
 {
-DP_IN("CntCache::onNewIcon(" << iconName << ", HbIcon)");
+CNT_ENTRY_ARGS( iconName )
 QSet<int> contactsToNotify;
 if (mIconCache.contains(iconName)) {
 CntIconCacheItem* item = mIconCache.value(iconName);
 contactsToNotify = item->contactIds;
 item->contactIds.clear();
 }
 foreach (int contactId, contactsToNotify) {
-DP("CntCache::onNewIcon() : new icon => emitting contactInfoUpdated(" << contactId << ")");
 emitContactInfoUpdated(contactId);
 }
-DP_OUT("CntCache::onNewIcon(" << iconName << ", HbIcon)");
+CNT_EXIT
 }
 /*!
 Handle the case where a request for an icon is cancelled by the worker because
 of too many subsequent requests.
 */
 void CntCache::onIconCancelled(const QString& iconName)
 {
-DP_IN("CntCache::onIconCancelled(" << iconName << ")");
+CNT_ENTRY_ARGS( iconName )
 QSet<int> contactsToNotify;
 if (mIconCache.contains(iconName)) {
 CntIconCacheItem* item = mIconCache.take(iconName);
 item->contactIds.clear();
 delete item;
 }
 foreach (int contactId, contactsToNotify) {
-DP("CntCache::onIconCancelled() : icon cancelled => emitting contactInfoUpdated(" << contactId << ")");
 emitContactInfoUpdated(contactId);
 }
-DP_OUT("CntCache::onIconCancelled(" << iconName << ")");
+CNT_EXIT
+}
+/*!
+Update contacts in cache.
+/param contactIds ids of the contact that will be updated
+*/
+void CntCache::updateContactsInCache(const QList<QContactLocalId>& contactIds)
+{
+CNT_ENTRY
+QString name;
+foreach (QContactLocalId contactId, contactIds) {
+if (mInfoCache.contains(contactId) && fetchContactName(contactId, name)) {
+CntInfoCacheItem* infoItem = mInfoCache.value(contactId);
+infoItem->name = name;
+mWorker->scheduleInfoJob(contactId);
+}
+}
+foreach (QContactLocalId contactId, contactIds) {
+emitContactInfoUpdated(contactId);
+}
+CNT_EXIT
 }
 /*!
 Removes contacts from cache.
 /param contactIds ids of the contact that will be removed
 */
 void CntCache::removeContactsFromCache(const QList<QContactLocalId>& contactIds)
 {
-DP_IN("CntCache::removeContactsFromCache(idList[" << contactIds.count() << "])");
+CNT_ENTRY
 foreach (QContactLocalId contactId, contactIds) {
 if (mInfoCache.contains(contactId)) {
 CntInfoCacheItem* item = mInfoCache.take(contactId);
 delete item;
 foreach (QContactLocalId contactId, contactIds) {
 emitContactInfoUpdated(contactId);
 }
-DP_OUT("CntCache::removeContactsFromCache(idList[" << contactIds.count() << "])");
+CNT_EXIT
 }
 /*!
 Uses an optimized function to fetch the name of a contact from
 the database.
 /param contactName the name will be stored here if the function is successful
 /return true if the name was fetched successfully
 */
 bool CntCache::fetchContactName(int contactId, QString& contactName)
 {
+CNT_ENTRY_ARGS( contactId )
 bool foundContact = false;
-DP_IN("CntCache::fetchContactName(" << contactId << "," << contactName << ")");
 QContactFetchHint nameOnlyFetchHint;
 QStringList details;
 details << QContactDisplayLabel::DefinitionName;
 nameOnlyFetchHint.setDetailDefinitionsHint(details);
 QContact contact = mContactManager->contact(contactId, nameOnlyFetchHint);
 if (mContactManager->error() == QContactManager::NoError) {
 contactName = contact.displayLabel();
 foundContact = true;
-// TODO: this can be removed once qt mobility is updated (~wk20/10)
+}
-if (contactName == "Unnamed") {
-contactName = "";
+CNT_EXIT_ARGS( foundContact )
-}
-}
-DP_OUT("CntCache::fetchContactName(" << contactId << "," << contactName << ") : " << foundContact);
 return foundContact;
 }
 /*!
 \param mostRecentRow the row of the contact that was most recently fetched
 \param idList a list with all the IDs in the list
 */
 void CntCache::updateReadAheadCache(int mostRecentRow, const QList<QContactLocalId>& idList)
 {
-DP_IN("CntCache::updateReadAheadCache(" << mostRecentRow << ", idList[" << idList.count() << "] )");
+CNT_ENTRY_ARGS( mostRecentRow )
 int row;
 mReadAheadCache.clear();
 // step through the area near to last fetch item and make sure all
 mInfoCache.value(contactId)->cacheOrder = mNextInfoCacheOrder++;
 }
 }
 }
-DP_OUT("CntCache::updateReadAheadCache(" << mostRecentRow << ", idList[" << idList.count() << "] )");
+CNT_EXIT
 }
 /*!
 Schedules one uncached item in the read-ahead list for retrieval.
 */
 void CntCache::scheduleOneReadAheadItem()
 {
-DP_IN("CntCache::scheduleOneReadAheadItem()");
+CNT_ENTRY
 QString name;
 while (mReadAheadCache.count() > 0) {
 int contactId = mReadAheadCache.takeFirst();
 break;
 }
 }
 }
-DP_OUT("CntCache::scheduleOneReadAheadItem()");
+CNT_EXIT
 }
 /*!
 Creates a new item in the info cache. If the cache is full,
 then the least recently accessed item is removed from cache.
 /param contactId id of contact for which to create the new cache item
 /return the newly created cache item
 */
 CntInfoCacheItem* CntCache::createInfoCacheItem(int contactId)
 {
-DP_IN("CntCache::createInfoCacheItem(" << contactId << ")");
+CNT_ENTRY_ARGS( contactId )
 if (mInfoCache.count() >= InfoCacheSize) {
 // cache is full, so remove the oldest contact
 int minCacheOrder = mNextInfoCacheOrder;
 CntInfoCacheItem* oldestItem = NULL;
 CntInfoCacheItem* item = new CntInfoCacheItem();
 item->cacheOrder = mNextInfoCacheOrder++;
 item->contactId = contactId;
 mInfoCache.insert(contactId, item);
-DP_OUT("CntCache::createInfoCacheItem(" << contactId << ")");
+CNT_EXIT
 return item;
 }
 /*!
 /param iconName name of the icon for which to create the new cache item
 /return the newly created cache item
 */
 CntIconCacheItem* CntCache::createIconCacheItem(const QString& iconName)
 {
-DP_IN("CntCache::createIconCacheItem(" << iconName << ")");
+CNT_ENTRY_ARGS( iconName )
 if (mIconCache.count() >= IconCacheSize) {
 // cache is full, so remove the oldest icon
 int minCacheOrder = mNextIconCacheOrder;
 CntIconCacheItem* oldestItem = NULL;
 item->cacheOrder = mNextIconCacheOrder++;
 item->iconName = iconName;
 item->isFetched = false;
 mIconCache.insert(iconName, item);
-DP_OUT("CntCache::createIconCacheItem(" << iconName << ")");
+CNT_EXIT
 return item;
 }
 /*!
 Clients can then request the info via fetchContactInfo()
 if they are interested.
 */
 void CntCache::emitContactInfoUpdated(int contactId)
 {
+	CNT_ENTRY_ARGS( contactId )
 mEmittedContactId = contactId;
 emit contactInfoUpdated(contactId);
 mEmittedContactId = -1;
+	CNT_EXIT
 }
 /*!
 Deletes the cache.
 */
 void CntCache::onShutdown()
 {
+	CNT_ENTRY
 delete this;
+	CNT_EXIT
 }
 /*!
 Creates an empty object.

changeset 46	efe85016a067
parent 40	b46a585f6909
child 47	7cbcb2896f0e