FCL/sf/mw/qtextensions: comparison qtmobility/src/messaging/qmtmengine

equal deleted inserted replaced

-:453da2cfceef
+:71781823f776
 #include <cmsvrecipientlist.h>
 #include <imapset.h>
 #include <miutmsg.h>
 #include <charconv.h>
 #include <imcvtext.h> // KImcvMultipart declaration
+#include <smscmds.h>
 #include <QTextCodec>
+#include <messagingutil_p.h>
 QTM_BEGIN_NAMESPACE
 const TInt KWaitAfterReceivedMessage = 100000; // = 0.1 seconds
 #define KDocumentsEntryIdValue    0x1008
 {
 iFsSession.Connect();
 CActiveScheduler::Add(this);
 iTimer.CreateLocal();
 TRAPD(err,
 ipMsvSession = CMsvSession::OpenSyncL(*this);
 iSessionReady = ETrue;
 ipClientMtmReg = CClientMtmRegistry::NewL(*ipMsvSession);
 ipSmsMtm = static_cast<CSmsClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeSMS));
 ipMmsMtm = static_cast<CMmsClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeMultimedia));
 );
 Q_UNUSED(err)
 // Create & Add SMS Account
 TRAPD(accountError,
-iSMSAccountidAsString = QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeSMS));
+iSMSAccountidAsString = SymbianHelpers::addIdPrefix(QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeSMS)),SymbianHelpers::EngineTypeMTM);
 QMessageAccount smsAcc = QMessageAccountPrivate::from(QMessageAccountId(iSMSAccountidAsString),
 QString("SMS"),
 mtmServiceEntryIdL(CMTMEngine::MTMTypeSMS),
 0,
 QMessage::Sms);
 iAccounts.insert(iSMSAccountidAsString, smsAcc);
 // Create & Add MMS Account
-iMMSAccountidAsString = QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeMMS));
+iMMSAccountidAsString = SymbianHelpers::addIdPrefix(QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeMMS)),SymbianHelpers::EngineTypeMTM);
 QMessageAccount mmsAcc = QMessageAccountPrivate::from(QMessageAccountId(iMMSAccountidAsString),
 QString("MMS"),
 mtmServiceEntryIdL(CMTMEngine::MTMTypeMMS),
 0,
 QMessage::Mms | QMessage::Email);
 TSmtpAccount defaultAccount;
 TInt err = pEmailAccounts->DefaultSmtpAccountL(defaultAccount);
 if (err == KErrNone) {
 QString idAsString;
 if (defaultAccount.iRelatedService != 0) {
-idAsString = QString::number(defaultAccount.iRelatedService);
+idAsString = SymbianHelpers::addIdPrefix(QString::number(defaultAccount.iRelatedService),SymbianHelpers::EngineTypeMTM);
 } else {
-idAsString = QString::number(defaultAccount.iSmtpService);
+idAsString = SymbianHelpers::addIdPrefix(QString::number(defaultAccount.iSmtpService),SymbianHelpers::EngineTypeMTM);
 }
 if (!iAccounts.contains(idAsString)) {
 QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(idAsString),
 QString::fromUtf16(defaultAccount.iSmtpAccountName.Ptr(), defaultAccount.iSmtpAccountName.Length()),
 defaultAccount.iRelatedService,
 RArray<TImapAccount> imapAccounts(10);
 pEmailAccounts->GetImapAccountsL(imapAccounts);
 CleanupClosePushL(imapAccounts);
 for (int i=0; i < imapAccounts.Count(); i++) {
-QString idAsString = QString::number(imapAccounts[i].iImapService);
+QString idAsString = SymbianHelpers::addIdPrefix(QString::number(imapAccounts[i].iImapService),SymbianHelpers::EngineTypeMTM);
 if (!iAccounts.contains(idAsString)) {
 QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(idAsString),
 QString::fromUtf16(imapAccounts[i].iImapAccountName.Ptr(), imapAccounts[i].iImapAccountName.Length()),
 imapAccounts[i].iImapService,
 imapAccounts[i].iSmtpService,
 RArray<TPopAccount> popAccounts(10);
 pEmailAccounts->GetPopAccountsL(popAccounts);
 CleanupClosePushL(popAccounts);
 for (int i=0; i < popAccounts.Count(); i++) {
-QString idAsString = QString::number(popAccounts[i].iPopService);
+QString idAsString = SymbianHelpers::addIdPrefix(QString::number(popAccounts[i].iPopService),SymbianHelpers::EngineTypeMTM);
 if (!iAccounts.contains(idAsString)) {
-QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(QString::number(popAccounts[i].iPopService)),
+QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(SymbianHelpers::addIdPrefix(QString::number(popAccounts[i].iPopService),SymbianHelpers::EngineTypeMTM)),
 QString::fromUtf16(popAccounts[i].iPopAccountName.Ptr(), popAccounts[i].iPopAccountName.Length()),
 popAccounts[i].iPopService,
 popAccounts[i].iSmtpService,
 QMessage::Email);
 iAccounts.insert(idAsString, account);
 RArray<TSmtpAccount> smtpAccounts(10);
 pEmailAccounts->GetSmtpAccountsL(smtpAccounts);
 CleanupClosePushL(smtpAccounts);
 for (int i=0; i < smtpAccounts.Count(); i++) {
 if (smtpAccounts[i].iRelatedService == 0) {
-QString idAsString = QString::number(smtpAccounts[i].iSmtpService);
+QString idAsString = SymbianHelpers::addIdPrefix(QString::number(smtpAccounts[i].iSmtpService),SymbianHelpers::EngineTypeMTM);
 if (!iAccounts.contains(idAsString)) {
-QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(QString::number(smtpAccounts[i].iSmtpService)),
+QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(SymbianHelpers::addIdPrefix(QString::number(smtpAccounts[i].iSmtpService),SymbianHelpers::EngineTypeMTM)),
 QString::fromUtf16(smtpAccounts[i].iSmtpAccountName.Ptr(), smtpAccounts[i].iSmtpAccountName.Length()),
 smtpAccounts[i].iRelatedService,
 smtpAccounts[i].iSmtpService,
 QMessage::Email);
 iAccounts.insert(idAsString, account);
 return true;
 }
 void CMTMEngine::showMessageL(const QMessageId &id)
 {
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(pEntry);
 CBaseMtm* mtm = ipClientMtmReg->NewMtmL(pEntry->Entry().iMtm);
 CleanupStack::PushL(mtm);
 void CMTMEngine::retrieveL(const QMessageId &messageId, const QMessageContentContainerId& id)
 {
 Q_UNUSED(id); // all attachments are retrieved (cannot retrieve only one)
-long int messId = messageId.toString().toLong();
+long int messId = SymbianHelpers::stripIdPrefix(messageId.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messId);
 CleanupStack::PushL(pEntry);
 CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;
 return true;
 }
 void CMTMEngine::retrieveBodyL(const QMessageId& id) const
 {
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(pEntry);
 CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;
 return true;
 }
 void CMTMEngine::retrieveHeaderL(const QMessageId& id) const
 {
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(pEntry);
 CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;
 releaseCMsvEntryAndPopFromCleanupStack(pEntry);
 }
 bool CMTMEngine::removeMessageL(const QMessageId &id, QMessageManager::RemovalOption /*option*/)
 {
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(pEntry);
 if (pEntry->Entry().iMtm == KUidMsgTypeSMS) {
 if (!ipSmsMtm)
 delete iMessageQueries[index].findOperation;
 iMessageQueries.removeAt(index);
 }
 void CMTMEngine::applyOffsetAndLimitToMsgIds(QMessageIdList& idList, int offset, int limit) const
 {
 if (offset > 0) {
 if (offset > idList.count()) {
 idList.clear();
 switch (pf->_field) {
 case QMessageFolderFilterPrivate::Id:
 {
 if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
 QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
-if (pf->_value.toString().length() > 0) {
+if (pf->_value.toString().length() > QString(SymbianHelpers::mtmPrefix).length()) {
 bool folderOk = false;
 long int folderId = folderIdFromQMessageFolderId(QMessageFolderId(pf->_value.toString()));
 CMsvEntry* pEntry = retrieveCMsvEntryAndPushToCleanupStack(folderId);
 if (pEntry) {
 if (pEntry->Entry().iType == KUidMsvFolderEntry) {
 case QMessageFolderFilterPrivate::ParentAccountId:
 {
 if (pf->_comparatorType == QMessageFolderFilterPrivate::Equality) {
 QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
 if (cmp == QMessageDataComparator::Equal) {
-if (pf->_value.toString().length() > 0) {
+if (pf->_value.toString().length() > QString(SymbianHelpers::mtmPrefix).length()) {
 ids = folderIdsByAccountId(QMessageAccountId(pf->_value.toString()));
 }
 } else { // NotEqual
 ids = allFolders();
-if (pf->_value.toString().length() > 0) {
+if (pf->_value.toString().length() > QString(SymbianHelpers::mtmPrefix).length()) {
 QMessageFolderIdList ids2 = folderIdsByAccountId(QMessageAccountId(pf->_value.toString()));
 for (int i = 0; i < ids2.count(); i++) {
 ids.removeOne(ids2[i]);
 }
 }
 if (entry.iType == KUidMsvFolderEntry) {
 CMsvEntrySelection* pSelection = pEntry->ChildrenWithTypeL(KUidMsvFolderEntry);
 CleanupStack::PushL(pSelection);
 if (pSelection->Count() > 0) {
 for(TInt i = 0; i < pSelection->Count(); i++) {
-ids.append(QMessageFolderId(QString::number(pSelection->At(i))));
+ids.append(QMessageFolderId(SymbianHelpers::addIdPrefix(QString::number(pSelection->At(i)),SymbianHelpers::EngineTypeMTM)));
 }
 }
 CleanupStack::PopAndDestroy(pSelection);
 }
 releaseCMsvEntryAndPopFromCleanupStack(pEntry);
 QString nullString = "00000000";
 QString serviceEntryIdString = QString::number(serviceEntryId);
 serviceEntryIdString = nullString.left(8-serviceEntryIdString.length()) + serviceEntryIdString;
 QString folderIdString = QString::number(folderId);
 folderIdString = nullString.left(8-folderIdString.length()) + folderIdString;
-return serviceEntryIdString+folderIdString;
+return SymbianHelpers::addIdPrefix(serviceEntryIdString+folderIdString,SymbianHelpers::EngineTypeMTM);
 }
 TMsvId CMTMEngine::serviceEntryIdFromQMessageFolderId(const QMessageFolderId& folderId) const
 {
-return folderId.toString().left(8).toLong();
+return SymbianHelpers::stripIdPrefix(folderId.toString()).left(8).toLong();
 }
 TMsvId CMTMEngine::folderIdFromQMessageFolderId(const QMessageFolderId& folderId) const
 {
-return folderId.toString().right(8).toLong();
+return SymbianHelpers::stripIdPrefix(folderId.toString()).right(8).toLong();
 }
 void CMTMEngine::handleNestedFiltersFromFolderFilter(QMessageFolderFilter &filter) const
 {
 QMessageFolderFilterPrivate* pMFFilter = QMessageFolderFilterPrivate::implementation(filter);
 QMessage CMTMEngine::messageL(const QMessageId& id) const
 {
 QMessage message;
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(pEntry);
 if (pEntry->Entry().iMtm == KUidMsgTypeSMS) {
 if (!ipSmsMtm)
 // parentFolderId was not defined for new Message
 // => Message will be created into defined standard Folder (Default value is Drafts Folder)
 destinationFolderId =  standardFolderId(message.standardFolder());
 }
-// Current entry is the Draft folder.
+// Switch current SMS MTM context to folder entry
 ipSmsMtm->SwitchCurrentEntryL(destinationFolderId);
-// Create a new SMS message entry as a child of the current context.
-ipSmsMtm->CreateMessageL(KUidMsgTypeSMS.iUid);
+// Create a new SMS message entry as a child of the current context
-TMsvEntry entry = ipSmsMtm->Entry().Entry();
+//
+// Note: CreateMessageL sets following values to new message entry:
+//       entry.iType = KUidMsvMessageEntry;
+//       entry.iRelatedId = <ID of the current SMS service>;
+//       entry.iServiceId = KMsvLocalServiceIndexEntryId;
+//       entry.iMtm = <SMS Message Type UID>;
+//       entry.SetVisible(EFalse);
+//       entry.SetInPreparation(ETrue);
+//       entry.iDate.UniversalTime(); <= Not set in older platforms
+//
+// Note: CreateMessageL automatically creates SMS header
+//       that contains default service settings & default
+//       service center address
+//
+// Note: CreateMessageL switches current SMS MTM context to
+//       a new SMS message context
+ipSmsMtm->CreateMessageL(KUidMsgTypeSMS.iUid);
+// Get the current context (new message context)
+CMsvEntry& newMessageContext = ipSmsMtm->Entry();
+// Copy entry values from the new message context index entry
+TMsvEntry entry = newMessageContext.Entry();
+// Set priority values to message entry
 switch (message.priority()) {
 case QMessage::HighPriority:
 entry.SetPriority(EMsvHighPriority);
 break;
 case QMessage::NormalPriority:
 break;
 case QMessage::LowPriority:
 entry.SetPriority(EMsvLowPriority);
 break;
 }
+// Set message read status to message entry
 if (message.status() & QMessage::Read) {
 entry.SetUnread(false);
 entry.SetNew(false);
 } else {
 entry.SetUnread(true);
 entry.SetNew(true);
 }
-ipSmsMtm->Entry().ChangeL(entry);
+// Set first message addressee to message entry
+// and all message addressees to SMS message
 QList<QMessageAddress> list(message.to());
 if (!list.empty()){
 TPtrC16 receiver(KNullDesC);
 QString qreceiver;
 for (int i = 0; i < list.size(); ++i) {
 qreceiver = list.at(i).addressee();
 receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));
+if (i == 0) {
+// Set addressee to message entry
+entry.iDetails.Set(receiver);
+}
+// Add addressee to SMS message
 ipSmsMtm->AddAddresseeL(receiver);
-ipSmsMtm->SaveMessageL();
+}
 }
-}
+// Set body to message entry and SMS message
-CMsvStore* store = ipSmsMtm->Entry().EditStoreL();
-CleanupStack::PushL(store);
 QString body = message.textContent();
 if (!body.isEmpty()){
 TPtrC16 msg(reinterpret_cast<const TUint16*>(body.utf16()));
-if (!ipRichText) {
-ipCharFormatLayer = CCharFormatLayer::NewL();
+// Set body to message entry
-ipParaFormatLayer = CParaFormatLayer::NewL();
+entry.iDescription.Set(msg);
-ipRichText=CRichText::NewL(ipParaFormatLayer,ipCharFormatLayer);
-}
+// Set body to SMS message
-ipRichText->Reset();
+CRichText& body = ipSmsMtm->Body();
-ipRichText->InsertL(0, msg);
+body.Reset();
-store->StoreBodyTextL(*ipRichText);
+body.InsertL(0, msg);
-store->CommitL();
+}
-}
-CleanupStack::PopAndDestroy(store);
+// Set date to message entry
+if (!message.receivedDate().isNull() || !message.date().isNull()) {
+if (!message.date().isNull()) {
+entry.iDate = qDateTimeToSymbianTTime(message.date());
+} else {
+entry.iDate = qDateTimeToSymbianTTime(message.receivedDate());
+}
+}
+// Set new message's context's index entry to the specified values.
+// <=> Changes are set into cache only
+newMessageContext.ChangeL(entry);
+// Commit cached changes to the storage
+// Note: SaveMessageL sets following values to message entry:
+//       entry.SetVisible(ETrue);
+//       entry.SetInPreparation(EFalse);
+ipSmsMtm->SaveMessageL();
+// Get message id from new SMS message index entry
 QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
-privateMessage->_id = QMessageId(QString::number(entry.Id()));
+privateMessage->_id = QMessageId(SymbianHelpers::addIdPrefix(QString::number(entry.Id())));
-if (!message.receivedDate().isNull() || !message.date().isNull()) {
-// Change the date to given date
-CMsvEntry* pEntry = ipMsvSession->GetEntryL(entry.Id());
-CleanupStack::PushL(pEntry);
-TMsvEntry changedEntry = pEntry->Entry();
-if (!message.date().isNull()) {
-changedEntry.iDate = qDateTimeToSymbianTTime(message.date());
-} else {
-changedEntry.iDate = qDateTimeToSymbianTTime(message.receivedDate());
-}
-pEntry->ChangeL(changedEntry);
-CleanupStack::PopAndDestroy(pEntry);
-}
 }
 bool CMTMEngine::sendSMS(QMessage &message)
 {
 if (!iSessionReady) {
 }
 return true;
 }
+bool CMTMEngine::validateSMS()
+{
+// Validate SMS body.
+TMsvPartList result(KMsvMessagePartNone);
+result = ipSmsMtm->ValidateMessage(KMsvMessagePartBody);
+if (result != KMsvMessagePartNone ) {
+return false;
+}
+// Validate SMS recipient
+result = ipSmsMtm->ValidateMessage(KMsvMessagePartRecipient);
+if ( result != KMsvMessagePartNone ) {
+return false;
+}
+return true;
+}
 void CMTMEngine::sendSMSL(QMessage &message)
 {
 if (!iSessionReady) {
 User::Leave(KErrNotReady);
 }
 if (!message.id().isValid()) {
 QMessagePrivate::setStandardFolder(message, QMessage::DraftsFolder);
 storeSMSL(message);
 }
-long int messageId = message.id().toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(message.id().toString()).toLong();
 if (messageId == 0) {
 User::Leave(KErrNotReady);
 }
-CMsvEntry* pMsvEntry = retrieveCMsvEntryAndPushToCleanupStack(messageId);
+// Switch current SMS MTM context to message entry
-CMsvOperationWait* pMsvOperationWait = CMsvOperationWait::NewLC();
+ipSmsMtm->SwitchCurrentEntryL(messageId);
-ipSmsMtm->SwitchCurrentEntryL(pMsvEntry->Entry().Parent());
+// Load the cache with the message data
-// Following sends SMS and _moves_ SMS from Drafts Folder to Sent Folder
+ipSmsMtm->LoadMessageL();
-CMsvOperation* pMsvOperation = ipSmsMtm->Entry().CopyL(messageId, ipSmsMtm->ServiceId(), pMsvOperationWait->iStatus);
-pMsvOperationWait->Start();
+// Copy entry values from the message context index entry
-CActiveScheduler::Start();
+TMsvEntry entry = ipSmsMtm->Entry().Entry();
-delete pMsvOperation;
+// Update date to UniversalTime
-CleanupStack::PopAndDestroy(pMsvOperationWait);
+// <=> Date field is used to control message send time
-releaseCMsvEntryAndPopFromCleanupStack(pMsvEntry);
+entry.iDate.UniversalTime();
+// Update message sending state
+entry.SetSendingState(KMsvSendStateWaiting);
+// Set SMS Service & delivery settings to the SMS header
+CSmsHeader& smsHeader = ipSmsMtm->SmsHeader();
+CSmsSettings* pSmsSettings = CSmsSettings::NewL();
+CleanupStack::PushL(pSmsSettings);
+pSmsSettings->CopyL(ipSmsMtm->ServiceSettings());
+pSmsSettings->SetDelivery(ESmsDeliveryImmediately);
+pSmsSettings->SetDeliveryReport(EFalse);
+smsHeader.SetSmsSettingsL(*pSmsSettings);
+if (smsHeader.Message().ServiceCenterAddress().Length() == 0) {
+CSmsSettings* pSmsServiceSettings = &(ipSmsMtm->ServiceSettings());
+if (!pSmsServiceSettings->ServiceCenterCount()) {
+User::Leave(KErrNotReady);
+} else {
+CSmsNumber* pSmsCenterNumber = CSmsNumber::NewL();
+CleanupStack::PushL(pSmsCenterNumber);
+pSmsCenterNumber->SetAddressL((pSmsServiceSettings->GetServiceCenter(pSmsServiceSettings->DefaultServiceCenter())).Address());
+smsHeader.Message().SetServiceCenterAddressL(pSmsCenterNumber->Address());
+CleanupStack::PopAndDestroy(pSmsCenterNumber);
+}
+}
+CleanupStack::PopAndDestroy(pSmsSettings);
+// Update message's context's index entry to the new values.
+// <=> Changes are set into cache only
+ipSmsMtm->Entry().ChangeL(entry);
+// Commit cached changes to the storage
+ipSmsMtm->SaveMessageL();
+if (validateSMS()) {
+// Switch current SMS MTM context to SMS message parent folder entry
+ipSmsMtm->SwitchCurrentEntryL(ipSmsMtm->Entry().Entry().Parent());
+CMsvOperationWait* pMsvOperationWait = CMsvOperationWait::NewLC();
+// Move SMS Message to Outbox
+CMsvOperation* pMsvOperation = ipSmsMtm->Entry().MoveL(messageId,
+KMsvGlobalOutBoxIndexEntryId,
+pMsvOperationWait->iStatus);
+pMsvOperationWait->Start();
+CActiveScheduler::Start();
+delete pMsvOperation;
+// Send SMS Message
+CMsvEntrySelection* pMsvEntrySelection = new(ELeave) CMsvEntrySelection;
+CleanupStack::PushL(pMsvEntrySelection);
+// Add SMS Message Id to selection
+pMsvEntrySelection->AppendL(messageId);
+// Add selection (containing SMS Message Id) to task scheduler
+TBuf8<1> dummyParams;
+pMsvOperation = ipSmsMtm->InvokeAsyncFunctionL(ESmsMtmCommandScheduleCopy,
+*pMsvEntrySelection,
+dummyParams,
+pMsvOperationWait->iStatus);
+pMsvOperationWait->Start();
+CActiveScheduler::Start();
+delete pMsvOperation;
+CleanupStack::PopAndDestroy(pMsvEntrySelection);
+CleanupStack::PopAndDestroy(pMsvOperationWait);
+} else {
+User::Leave(KErrCorrupt);
+}
 }
 void CMTMEngine::storeMMSL(QMessage &message)
 {
 if (!iSessionReady) {
 }
 CleanupStack::PopAndDestroy(); // store
 QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
-privateMessage->_id = QMessageId(QString::number(indexEntry));
+privateMessage->_id = QMessageId(SymbianHelpers::addIdPrefix(QString::number(indexEntry,SymbianHelpers::EngineTypeMTM)));
 // Save the changes
 ipMmsMtm->SaveMessageL();
 if (!message.receivedDate().isNull() || !message.date().isNull()) {
 // Change the date to given date
 if (!iSessionReady) {
 User::Leave(KErrNotReady);
 }
 QMessageId id = message.id();
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 if (messageId == 0)
 return;
 CMsvEntry* entry = ipMsvSession->GetEntryL(messageId);
 CleanupStack::PushL(entry);
 if (!iSessionReady) {
 User::Leave(KErrNotReady);
 }
 QMessageId id = message.id();
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 if (messageId == 0)
 return;
 ipMmsMtm->SwitchCurrentEntryL(messageId);
 ipMmsMtm->LoadMessageL();
 if (!iSessionReady) {
 User::Leave(KErrNotReady);
 }
 QMessageId id = message.id();
-long int messageId = id.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(id.toString()).toLong();
 if (messageId == 0)
 return;
 CMsvEntry* pEntry = ipMsvSession->GetEntryL(messageId);
 TUid mtmUid = pEntry->Entry().iMtm;
 QMessagePrivate::setStandardFolder(message, QMessage::OutboxFolder);
 storeMMSL(message);
 messageCreated = true;
 }
-long int messageId = message.id().toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(message.id().toString()).toLong();
 if (messageId == 0) {
 User::Leave(KErrNotReady);
 }
 CMsvEntry* pMsvEntry = retrieveCMsvEntryAndPushToCleanupStack(messageId);
 releaseCMsvEntryAndPopFromCleanupStack(pMsvEntry);
 CleanupStack::PopAndDestroy(pMsvOperationWait);
 QMessagePrivate* privateMessage = QMessagePrivate::implementation(message);
-privateMessage->_id = QMessageId(QString::number(newMessageId));
+privateMessage->_id = QMessageId(SymbianHelpers::addIdPrefix(QString::number(newMessageId),SymbianHelpers::EngineTypeMTM));
 }
 void CMTMEngine::sendEmailL(QMessage &message)
 {
 if (!iSessionReady) {
 message.setParentAccountId(accountId);
 storeEmailL(message);
 messageCreated = true;
 }
-long int messageId = message.id().toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(message.id().toString()).toLong();
 if (messageId == 0) {
 User::Leave(KErrNotReady);
 }
 CMsvEntry* pMsvEntry = retrieveCMsvEntryAndPushToCleanupStack(messageId);
 aMsgType == KUidMsgTypeIMAP4) {
 message.setType(QMessage::Email);
 } else {
 message.setType(QMessage::NoType);
 }
 } else if ((privateMessageFilter->_field == QMessageFilterPrivate::StandardFolder) &&
 (aMsgType == KUidMsgTypeSMS || aMsgType == KUidMsgTypeMultimedia)) {
 if (aFolderId == KMsvGlobalInBoxIndexEntryId) {
 QMessagePrivate::setStandardFolder(message,QMessage::InboxFolder);
 } else if (aFolderId == KMsvDraftEntryId) {
 QMessagePrivate::setStandardFolder(message,QMessage::DraftsFolder);
 } else if (aFolderId == KMsvSentEntryId) {
 QMessagePrivate::setStandardFolder(message,QMessage::SentFolder);
 } else if (aFolderId == KMsvDeletedEntryFolderEntryId) {
 QMessagePrivate::setStandardFolder(message,QMessage::TrashFolder);
 }
 } else if (!messageRetrieved) {
-message = this->message(QMessageId(QString::number(aMessageId)));
+message = this->message(QMessageId(SymbianHelpers::addIdPrefix(QString::number(aMessageId),SymbianHelpers::EngineTypeMTM)));
 if (message.type() == QMessage::NoType) {
 unableToReadAndFilterMessage = true;
 matchingFilters.clear();
 break;
 } else {
 tryToDeliverMessageNotifications();
 } else {
 // No pending notification events for this messageId.
 // => Deliver notification immediately
 ipMessageStorePrivate->messageNotification(notificationType,
-QMessageId(QString::number(aMessageId)),
+QMessageId(SymbianHelpers::addIdPrefix(QString::number(aMessageId),SymbianHelpers::EngineTypeMTM)),
 matchingFilters);
 }
 } else if (unableToReadAndFilterMessage) {
 if (notificationType != QMessageStorePrivate::Removed) {
 MessageEvent event;
 while (count--) {
 // Try to deliver the oldest message event notification first
 MessageEvent event = iUndeliveredMessageEvents[0];
 bool eventHandlingPossible = true;
 if (event.notificationType != QMessageStorePrivate::Removed && event.unfiltered) {
-QMessage message = this->message(QMessageId(QString::number(event.messageId)));
+QMessage message = this->message(QMessageId(SymbianHelpers::addIdPrefix(QString::number(event.messageId),SymbianHelpers::EngineTypeMTM)));
 if (message.type() == QMessage::NoType) {
 eventHandlingPossible = false;
 } else {
 event.matchingFilters.clear();
 // Copy the filter map to protect against modification during traversal
 iUndeliveredMessageEvents.removeFirst();
 iDeliveryTriesCounter = 0;
 if (event.matchingFilters.count() > 0) {
 // Deliver message event notification
 ipMessageStorePrivate->messageNotification(event.notificationType,
-QMessageId(QString::number(event.messageId)),
+QMessageId(SymbianHelpers::addIdPrefix(QString::number(event.messageId),SymbianHelpers::EngineTypeMTM)),
 event.matchingFilters);
 }
 } else {
 // New message entry was NOT ready to be read
 iDeliveryTriesCounter++;
 // => return all messages
 ipEntrySelection = new(ELeave)CMsvEntrySelection;
 getAllMessagesL(iOrdering);
 iIdList = QMessageIdList();
 for (int i=0; i < ipEntrySelection->Count(); i++) {
-iIdList.append(QMessageId(QString::number((*ipEntrySelection)[i])));
+iIdList.append(QMessageId(SymbianHelpers::addIdPrefix(QString::number((*ipEntrySelection)[i]),SymbianHelpers::EngineTypeMTM)));
 }
 }
 iNumberOfHandledFilters++;
 iTimer.After(iStatus, 1);
 if (!IsActive()) {
 case QMessageFilterPrivate::Id:
 {
 iNumberOfHandledFilters++;
 if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageId
 QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
-if (!pf->_value.isNull() && pf->_value.toString().length() > 0) {
+if (!pf->_value.isNull() && pf->_value.toString().length() > QString(SymbianHelpers::mtmPrefix).length()) {
 if (cmp == QMessageDataComparator::Equal) {
-long int messageId = pf->_value.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(pf->_value.toString()).toLong();
 CMsvEntry* pEntry = iOwner.retrieveCMsvEntryAndPushToCleanupStack(messageId);
 if (pEntry) {
 const TMsvEntry& entry = pEntry->Entry();
 if (entry.iType == KUidMsvMessageEntry) {
 ipEntrySelection = new(ELeave)CMsvEntrySelection;
 }
 iResultCorrectlyOrdered = true;
 } else { // NotEqual
 ipEntrySelection = new(ELeave)CMsvEntrySelection;
 getAllMessagesL(iOrdering);
-long int messageId = pf->_value.toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(pf->_value.toString()).toLong();
 for (int i=0; i < ipEntrySelection->Count(); i++) {
 if (ipEntrySelection->At(i) == messageId) {
 ipEntrySelection->Delete(i);
 break;
 }
 QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(pf->_comparatorValue));
 if (pf->_ids.count() > 0) { // QMessageIdList
 if (cmp == QMessageDataComparator::Includes) {
 ipEntrySelection = new(ELeave)CMsvEntrySelection;
 for (int i=0; i < pf->_ids.count(); i++) {
-long int messageId = pf->_ids[i].toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(pf->_ids[i].toString()).toLong();
 CMsvEntry* pEntry = iOwner.retrieveCMsvEntryAndPushToCleanupStack(messageId);
 if (pEntry) {
 const TMsvEntry& entry = pEntry->Entry();
 if (entry.iType == KUidMsvMessageEntry) {
 ipEntrySelection->AppendL(messageId);
 }
 } else { // Excludes
 ipEntrySelection = new(ELeave)CMsvEntrySelection;
 getAllMessagesL(iOrdering);
 for (int i=0; i < pf->_ids.count(); i++) {
-long int messageId = pf->_ids[i].toString().toLong();
+long int messageId = SymbianHelpers::stripIdPrefix(pf->_ids[i].toString()).toLong();
 for (int i=0; i < ipEntrySelection->Count(); i++) {
 if (ipEntrySelection->At(i) == messageId) {
 ipEntrySelection->Delete(i);
 break;
 }
 case QMessageFilterPrivate::ParentFolderId:
 {
 if (pf->_comparatorType == QMessageFilterPrivate::Equality) { // QMessageFolderId
 QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(pf->_comparatorValue));
 if (cmp == QMessageDataComparator::Equal) {
 long int folderId = iOwner.folderIdFromQMessageFolderId(QMessageFolderId(pf->_value.toString()));
 long int serviceEntryId = iOwner.serviceEntryIdFromQMessageFolderId(QMessageFolderId(pf->_value.toString()));
 QMessageAccount messageAccount = iOwner.account(iOwner.accountIdByServiceId(serviceEntryId));
 if (messageAccount.messageTypes() == QMessage::Email) {
 iNumberOfHandledFilters++;
 CMsvEntryFilter* pFilter = CMsvEntryFilter::NewLC();
 SetActive();
 }
 } else {
 iIdList = QMessageIdList();
 for (int i=0; i < ipEntrySelection->Count(); i++) {
-iIdList.append(QMessageId(QString::number((*ipEntrySelection)[i])));
+iIdList.append(QMessageId(SymbianHelpers::addIdPrefix(QString::number((*ipEntrySelection)[i]),SymbianHelpers::EngineTypeMTM)));
 }
 iTimer.After(iStatus, 100);
 if (!IsActive()) {
 SetActive();
 }
 } else {
 if (ipMsvFindOperation) {
 const CMsvFindResultSelection& findResultSelection = ipMsvFindOperation->GetFindResult();
 QMessageIdList msgIds;
 for (int i=0; i < findResultSelection.Count(); i++) {
-msgIds.append(QMessageId(QString::number(findResultSelection[i].iId)));
+msgIds.append(QMessageId(SymbianHelpers::addIdPrefix(QString::number(findResultSelection[i].iId),SymbianHelpers::EngineTypeMTM)));
 }
 iOwner.filterAndOrderMessagesReady(true, iOperationId, msgIds, iNumberOfHandledFilters, iResultCorrectlyOrdered);
 } else {
 iOwner.filterAndOrderMessagesReady(true, iOperationId, iIdList, iNumberOfHandledFilters, iResultCorrectlyOrdered);
 }

changeset 8	71781823f776
parent 4	90517678cc4f
child 11	06b8e2af4411