diff -r 64e38f08e49c -r 47d84de1c893 emailservices/nmutilities/src/emailmru.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/emailservices/nmutilities/src/emailmru.cpp Mon Oct 04 00:05:37 2010 +0300 @@ -0,0 +1,350 @@ +/* + * Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "Eclipse Public License v1.0" + * which accompanies this distribution, and is available + * at the URL "http://www.eclipse.org/legal/epl-v10.html". + * + * Initial Contributors: + * Nokia Corporation - initial contribution. + * + * Contributors: + * + * Description: Object for accessing most recent used email addresses and + * display names. + * + */ + +#include "emailtrace.h" +#include "emailmru.h" + +#include +#include +#include + +/*! + Constructor + */ + +// ID 0, Last saved ID. +// ID 1, Count of MRU Items. + +EmailMRU::EmailMRU() +{ + NM_FUNCTION; + + mRepositoryManager = new XQSettingsManager(); + Q_CHECK_PTR(mRepositoryManager); + + mLatestIndex = readCenRep(currentIndexKey).toInt(); + mCount = readCenRep(countKey).toInt(); +} + +/*! + Destructor + */ +EmailMRU::~EmailMRU() +{ + NM_FUNCTION; + + QString entryIndex; + entryIndex.setNum(mLatestIndex); + + QString count; + count.setNum(mCount); + + writeCenRep(currentIndexKey, entryIndex); + writeCenRep(countKey, count); + + delete mRepositoryManager; +} + +/*! + Add entry to MRU database + \param displayName + \param emailAddress + \return success, was the update operation successful + */ +bool EmailMRU::updateMRU(QString displayName, QString emailAddress) +{ + NM_FUNCTION; + + bool success = false; + qint32 foundEntryIndex = searchForAddress(emailAddress); + if (foundEntryIndex) { + success = updateEntry(foundEntryIndex, displayName); + } + + else { + qint32 entryIndex = getNextEntryIndex(); + success = writeEntry(entryIndex, displayName, emailAddress); + mCount++; + if (mCount > emailAddressHistorySize) { + mCount = emailAddressHistorySize; + } + } + + return success; +} + +/*! + Get the number of entries + \return number of entries + */ +quint32 EmailMRU::entryCount() const +{ + return mCount; +} + +/*! + Get entry details + \param entryIndex entry index to look for + \param displayName will contain displayname of entry if found + \param address will contain address of entry if found + \return success + */ +bool EmailMRU::getEntry(qint32 entryIndex, QString &displayName, QString &address) +{ + NM_FUNCTION; + + bool success = false; + + if ((entryIndex >= 1) && (mCount > 0)) { + displayName = readCenRep(nameKeyByEntryIndex(entryIndex)); + address = readCenRep(addressKeyByEntryIndex(entryIndex)); + success = true; + + if (address.size()==0) { + success = false; + } + } + + return success; +} + +/*! + Resets repository + */ +void EmailMRU::reset() +{ + NM_FUNCTION; + + XQCentralRepositoryUtils utils(*mRepositoryManager); + utils.resetRepository(emailMruRepositoryKey); + mLatestIndex = 0; + mCount = 0; +} + +/*! + Writes to central repository + \param index where to write + \param value what to write + \return success, whether write operation succeeded + */ +bool EmailMRU::writeCenRep(qint32 index, QString value) +{ + NM_FUNCTION; + + XQCentralRepositorySettingsKey writeKey(emailMruRepositoryKey, index); + bool success = mRepositoryManager->writeItemValue(writeKey, value); + if (!success) { + XQCentralRepositoryUtils utils(*mRepositoryManager); + success = utils.createKey(writeKey, value); + } + + return success; +} + +/*! + Reads from central repository + \param index to read + \return value + */ +QString EmailMRU::readCenRep(qint32 index) +{ + NM_FUNCTION; + + XQCentralRepositorySettingsKey readKey(emailMruRepositoryKey, index); + return mRepositoryManager->readItemValue(readKey, XQSettingsManager::TypeString).value (); +} + +/*! + Translates entry indexes into real central repository indexes + \return central repository index + */ +quint32 EmailMRU::getNextEntryIndex() +{ + NM_FUNCTION; + + mLatestIndex++; + + if (mLatestIndex > emailAddressHistorySize) { + mLatestIndex = 1; + } + + return mLatestIndex; +} + +/*! + Translates central repository indexes into entry index + \param realIndex central repository index + \return entry index + */ +qint32 EmailMRU::entryIndex(qint32 crKey) +{ + NM_FUNCTION; + + qint32 entryIndex = 0; + + if (crKey%2 == 0){ + entryIndex = crKey/2; + } + else { + entryIndex = (crKey-1)/2; + } + + return entryIndex; +} + +/*! + Translates entry index into cenrep email address index + \param entryIndex + \return cenrep email address index + */ +qint32 EmailMRU::addressKeyByEntryIndex(qint32 entryIndex) +{ + return entryIndex*2+1; +} + +/*! + Translates entry index into cenrep displayname index + \param entryIndex + \return cenrep displayname index + */ +qint32 EmailMRU::nameKeyByEntryIndex(qint32 entryIndex) +{ + return entryIndex*2; +} + +/*! + Checks if MRU list already contains the address + \param address to search + \return entry index of found address, zero if not found + */ +qint32 EmailMRU::searchForAddress(QString address) +{ + NM_FUNCTION; + + quint32 partialKey(0x00000000); + quint32 bitMask(0x00000000); + XQCentralRepositorySearchCriteria criteria(emailMruRepositoryKey, partialKey, bitMask); + criteria.setValueCriteria(address); + + // Find the keys. + XQCentralRepositoryUtils utils(*mRepositoryManager); + QList foundKeys = utils.findKeys(criteria); + + qint32 index = 0; + // We should only get one key as a result. + if (foundKeys.count() == 1) { + index = foundKeys[0].key(); + } + return entryIndex(index); +} + +/*! + Moves entry, will overwrite the newEntryIndex + \param oldEntryIndex entry to be moved + \param newEntryIndex where to move + */ +void EmailMRU::moveEntry(qint32 oldEntryIndex, qint32 newEntryIndex) +{ + NM_FUNCTION; + + // Save the values to be moved + QString name = readCenRep(nameKeyByEntryIndex(oldEntryIndex)); + QString address = readCenRep(addressKeyByEntryIndex(oldEntryIndex)); + + // Overwrite values into new entry + writeEntry(newEntryIndex, name, address); +} + +/*! + Updates displayname and sets entry as newest + \param entryIndex to update + \param newDisplayName + \return success was update operation successfull + */ +bool EmailMRU::updateEntry(qint32 entryIndex, QString newDisplayName) +{ + NM_FUNCTION; + + // Save address + QString address = readCenRep(addressKeyByEntryIndex(entryIndex)); + + // Move all entries following the one to be updated + // until we go past the newest entry + for (qint32 i = entryIndex, j = 0; i != mLatestIndex;) { + j = i+1; + if (j > emailAddressHistorySize) j = 1; + + moveEntry(j, i); + + i++; + if (i > emailAddressHistorySize) i = 1; + } + + // Write the updated entry as the newest entry + return writeEntry(mLatestIndex, newDisplayName, address); +} + +/*! + Writes entry. Overwrites any existing data at give index + \param entryIndex to write + \param displayName + \param emailAddress + \return success was update operation successfull + */ +bool EmailMRU::writeEntry(qint32 entryIndex, QString displayName, QString emailAddress) +{ + NM_FUNCTION; + + bool nameSuccess = false; + bool addressSuccess = false; + + nameSuccess = writeCenRep(nameKeyByEntryIndex(entryIndex), displayName); + if (nameSuccess) { + addressSuccess = writeCenRep(addressKeyByEntryIndex(entryIndex), emailAddress); + } + + // Writing name succeeded but writing address not, we destroy the name + if (!addressSuccess) { + XQCentralRepositoryUtils utils(*mRepositoryManager); + XQCentralRepositorySettingsKey deleteKey(emailMruRepositoryKey, nameKeyByEntryIndex(entryIndex)); + utils.deleteKey(deleteKey); + } + + return (nameSuccess & addressSuccess); +} + +/*! + Writes entry. Overwrites any existing data at give index + \return contacts setting for lastname / firstname order. + */ +int EmailMRU::nameOrder() +{ + XQSettingsManager *repositoryManager = new XQSettingsManager(); + Q_CHECK_PTR(repositoryManager); + + XQCentralRepositorySettingsKey readKey(contactsRepositoryKey, + nameOrderKey); + + int nameOrder = repositoryManager->readItemValue(readKey, + XQSettingsManager::TypeInt).toInt(); + + delete repositoryManager; + + return nameOrder; +} +