void CMtfTestActionDeleteEntry::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeleteEntry); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(paramEntryId); entry->SetEntryL(entry->Entry().Parent()); if (entry->OwningService() == KMsvLocalServiceIndexEntryId) { entry->DeleteL(paramEntryId); DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TestCase().ActionCompletedL(*this); } else { iOperation = entry->DeleteL(paramEntryId,iStatus); SetActive(); } CleanupStack::PopAndDestroy(entry); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeleteEntry); }
/** doTestStepL() Performs the comparison of POP messages @return Returns the teststep result. */ TVerdict CT_MsgComparePopEmailMsgs::doTestStepL() { INFO_PRINTF1(_L("Test Step: Compare Pop Email Msgs")); if(LoadParametersL()) { User::LeaveIfError(iFs.Connect()); CleanupClosePushL(iFs); // Normally do not push an object that is a data member of another object. // But in this case we want to close early if we get a leave. // Otherwise the iFs would be open till the thread had begun to die. if(TestStepResult() == EPass) { CMsvEntry* recvMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId); CleanupStack::PushL(recvMsvEntry); CMsvEntry* sentMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId); CleanupStack::PushL(sentMsvEntry); for(TInt i = 0;i < iInboxSelectionList->Count();i++) { recvMsvEntry->SetEntryL(iInboxSelectionList->At(i)); TMsvEntry recvEntry = recvMsvEntry->Entry(); for(TInt j = 0;j < iSentSelectionList->Count();j++) { sentMsvEntry->SetEntryL(iSentSelectionList->At(j)); TMsvEntry sentEntry = sentMsvEntry->Entry(); if(recvEntry.iDescription.Compare(sentEntry.iDescription) == 0) { CExpPop3MailInfo* pExpMailInfo = NULL; for(int k = 0;k < iExpResults.Count();k++) { if(iExpResults[k]->GetDescription().Compare(recvEntry.iDescription) == 0) { pExpMailInfo = iExpResults[k]; break; } } if(! pExpMailInfo) { ERR_PRINTF2(_L("Test %d failed could not retrieve expected mail info"), j+1); SetTestStepResult(EFail); break; } if(! DoCompareL(recvEntry, *pExpMailInfo, sentEntry)) { INFO_PRINTF2(_L("Test %d failed"), j + 1); SetTestStepResult(EFail); } } } } CleanupStack::PopAndDestroy(2, recvMsvEntry); // recvMsvEntry, sentMsvEntry } CleanupStack::PopAndDestroy(); } INFO_PRINTF1(_L("T_ComparePopEmailMsgs Completed")); return TestStepResult(); }
TInt CMtfTestActionCheckChildrenCountWithFlagBase::CountChildrenL(TMsvId aParent, CMsvSession& aSession) { TInt children = 0; // Get children at this level CMsvEntry* entryContext = CMsvEntry::NewL(aSession, aParent, TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue)); CleanupStack::PushL(entryContext); entryContext->SetEntryL(aParent); TMsvSelectionOrdering order; order.SetShowInvisibleEntries(ETrue); entryContext->SetSortTypeL(order); CMsvEntrySelection* selection = entryContext->ChildrenL(); CleanupStack::PushL(selection); // for each child TInt count=selection->Count(); for(TInt child=0;child<count;child++) { entryContext->SetEntryL((*selection)[child]); TMsvEntry entry=entryContext->Entry(); if (entry.iType==KUidMsvMessageEntry && FlagIsSet(entry) ) { ++children; } // if this is a folder then recurse if (entry.iType==KUidMsvFolderEntry) children +=CountChildrenL((*selection)[child], aSession); } CleanupStack::PopAndDestroy(2); // selection,entryContext return children; }
LOCAL_C void TestReadOnlyDeletionL() { CDummyObserver* ob = new(ELeave)CDummyObserver; CleanupStack::PushL(ob); CMsvSession* session = CMsvSession::OpenSyncL(*ob); CleanupStack::PushL(session); CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering()); CleanupStack::PushL(cEntry); // Create an entry TMsvEntry entry; entry.iType = KUidMsvMessageEntry; entry.iMtm = KUidMsvLocalServiceMtm; entry.iServiceId = KMsvLocalServiceIndexEntryId; cEntry->CreateL(entry); // Generate name of attachment cEntry->SetEntryL(entry.Id()); TFileName fileName; fileName.Append(_L("Test")); CMsvStore* store = cEntry->EditStoreL(); CleanupStack::PushL(store); CAsyncWaiter* waiter = CAsyncWaiter::NewL(); CleanupStack::PushL(waiter); CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); CleanupStack::PushL(attachment); fileName.Append(_L("Test")); attachment->SetAttachmentNameL(fileName); RFile file; store->AttachmentManagerL().CreateAttachmentL(fileName, file, attachment, waiter->iStatus); CleanupStack::Pop(attachment); // ownership passed waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); CleanupClosePushL(file); User::LeaveIfError(file.Write(_L8("some text"))); User::LeaveIfError(file.SetAtt(KEntryAttReadOnly, KEntryAttNormal)); CleanupStack::PopAndDestroy(2, store); // file, store // Now try and delete the file cEntry->SetEntryL(entry.Parent()); cEntry->DeleteL(entry.Id()); CleanupStack::PopAndDestroy(3); // cEntry, session, ob }
/** Delete Existing Service @param aSession Current Session reference @internalTechnology */ void CentralRepoUtils::DeleteServiceL(CMsvSession* aSession) { TMsvId serviceId; TRAPD(err,TSmsUtilities::ServiceIdL(*aSession,serviceId)); if(err !=KErrNotFound) { CMsvEntry* entry = CMsvEntry::NewL(*aSession,serviceId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(serviceId); entry->SetEntryL(entry->Entry().Parent()); entry->DeleteL(serviceId); CleanupStack::PopAndDestroy(entry); } }
/** GetMessagePartIndexL() Retrieves the part index id for the email identified by aEntry @param aEntry A valid email identifier @param aUid An identifier tfor the type of message part to be retrieved @return TMsvId - message part identifier */ TMsvId CT_MsgComparePopEmailMsgs::GetMessagePartIndexL(TMsvEntry& aEntry, TUid aUid) { static TBool msgPartFound = EFalse; TMsvId msgPartId = 0; CMsvEntry* baseEntry = iSharedDataPOP.iSession->GetEntryL(aEntry.Id()); CleanupStack::PushL(baseEntry); CMsvEntrySelection* selection = baseEntry->ChildrenL(); CleanupStack::PushL(selection); TInt count = selection->Count(); TInt ind1; CMsvEntry* entry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId); CleanupStack::PushL(entry); for (ind1=0, msgPartFound=EFalse; ind1 < count; ind1++) { if(msgPartFound) { break; } TMsvId childId = selection->At(ind1); entry->SetEntryL(childId); if (entry->Entry().iType == aUid) { msgPartId = childId; break; } else if (entry->Entry().iType == KUidMsvFolderEntry) { TMsvEntry ent = entry->Entry(); msgPartId = GetMessagePartIndexL(ent, aUid); } } CleanupStack::PopAndDestroy(3, baseEntry); // entry,selection,baseEntry return msgPartId; }
void CScheduleTestActive::HandleSessionEventL(TMsvSessionEvent eventType, TAny* p1, TAny*, TAny*) { if (iStopAtRunL) return; if (eventType != EMsvEntriesCreated) return; CMsvEntrySelection* entries = STATIC_CAST(CMsvEntrySelection*, p1); CMsvEntry* cEntry = iSession.GetEntryL((*entries)[0]); CleanupStack::PushL(cEntry); TMsvEntry entry(cEntry->Entry()); if(entry.iDetails == KSchSendTestDetails) { iTest.Printf(_L("Scheduled message has been sent\n")); //We found the right message! CActiveScheduler::Stop(); //Delete the new message CMsvOperationWait* wait = CMsvOperationWait::NewLC(); wait->Start(); cEntry->SetEntryL(entry.Parent()); CMsvOperation* op = cEntry->DeleteL(entry.Id(), wait->iStatus); CActiveScheduler::Start(); delete op; CleanupStack::PopAndDestroy(wait); } CleanupStack::PopAndDestroy(cEntry); }
void CT_CMsvSession::TestIncPcSyncCountL() { TInt error = KErrGeneral; INFO_PRINTF1(_L("Testing: Increment PC Sync Count -- started")); TRAP(error, iSession = CMsvSession::OpenSyncL(*this)); TEST(error == KErrNone); CMsvOperationWait* active = CMsvOperationWait::NewLC(); CMsvEntry* cEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering()); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection; CleanupStack::PushL(selection); TInt ret = iSession->InstallMtmGroup(KDataComponentFilename); TEST(ret==KErrNone|| ret==KErrAlreadyExists); cEntry->SetEntryL(KMsvRootIndexEntryId); TMsvEntry service; service.iType=KUidMsvServiceEntry; service.iMtm = KUidTestServerMtmType; cEntry->CreateL(service); selection->AppendL(service.Id()); TBuf8<256> progress; TBuf8<32> param; TRAP(error, iSession->IncPcSyncCountL(*selection);)
void CMtfTestActionSetUserResponse::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSetUserResponse); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession> (TestCase(),ActionParameters().Parameter(0)); TInt paramUserResponse = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(1),EFalse); CMsvEntry* cEntry = CMsvEntry::NewL(*paramSession, KMsvDraftEntryId, TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue)); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = cEntry->ChildrenL(); CleanupStack::PushL(selection); TestCase().INFO_PRINTF2(_L("Count of Draft Folder's selection is %d"),selection->Count()); if (selection->Count() == 0) { User::Leave(KErrNotFound); } cEntry->SetEntryL((*selection)[0]); if (!paramUserResponse) { TMsvEntry entry = cEntry->Entry(); entry.iError = KErrCancel; cEntry->ChangeL(entry); } CleanupStack::PopAndDestroy(2); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSetUserResponse); TestCase().ActionCompletedL(*this); }
void CheckNoAttachmentsL() { CDummyObserver* ob1 = new(ELeave) CDummyObserver; CleanupStack::PushL(ob1); CMsvSession* session = CMsvSession::OpenSyncL(*ob1); CleanupStack::PushL(session); CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue)); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = cEntry->ChildrenL(); CleanupStack::PushL(selection); test(selection->Count() == 1); cEntry->SetEntryL((*selection)[0]); if (cEntry->HasStoreL()) { CMsvStore* store = cEntry->ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL(); test(attachmentMgr.AttachmentCount() == 0); CleanupStack::PopAndDestroy(store); } CleanupStack::PopAndDestroy(4, ob1); // selection, cEntry, session, ob1 }
void CMtfTestActionCopyEntry::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCopyEntry); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvId paramTargetId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(paramEntryId); entry->SetEntryL(entry->Entry().Parent()); iOperation = entry->CopyL(paramEntryId,paramTargetId,iStatus); CleanupStack::PopAndDestroy(entry); CActiveScheduler::Add(this); SetActive(); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCopyEntry); }
void CMtfTestActionDeletePop3Service::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeletePop3Service); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramServiceId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(paramServiceId); entry->SetEntryL(entry->Entry().Parent()); entry->DeleteL(paramServiceId); CleanupStack::PopAndDestroy(entry); DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeletePop3Service); TestCase().ActionCompletedL(*this); }
CMsvOperation* CTextMtmClient::ForwardL(TMsvId aForwardEntryId, TMsvPartList aPartList, TRequestStatus& aCompletionStatus) // Create forwarded message // Destination folder is aForwardEntryL // { __ASSERT_DEBUG(iMsvEntry!=NULL,gPanic(ETxtcNoCMsvEntrySet)); __ASSERT_DEBUG(iMsvEntry->Entry().iType.iUid == KUidMsvMessageEntryValue, gPanic(ETxtcEntryTypeNotSupported)); __ASSERT_DEBUG(iMsvEntry->Entry().iServiceId == KMsvLocalServiceIndexEntryId, gPanic(ETxtcInvalidServiceId)); // Create the forwarded index entry TMsvEntry forwardEntry; forwardEntry.iMtm = KUidMsgTypeText; forwardEntry.iServiceId = Entry().Entry().iServiceId; forwardEntry.iType = KUidMsvMessageEntry; forwardEntry.iDetails.Set(iMsvEntry->Entry().iDetails); forwardEntry.iSize = iMsvEntry->Entry().iSize; if(aPartList&KMsvMessagePartDate) forwardEntry.iDate.HomeTime(); if(aPartList&KMsvMessagePartDescription) forwardEntry.iDescription.Set(iMsvEntry->Entry().iDescription); // Get CMsvEntry for destination (parent) CMsvEntry* cEntry = CMsvEntry::NewL(Session(), aForwardEntryId, TMsvSelectionOrdering()); CleanupStack::PushL(cEntry); // Synchronously create new child CMsvOperationActiveSchedulerWait* wait = CMsvOperationActiveSchedulerWait::NewLC(); CMsvOperation* opert = cEntry->CreateL(forwardEntry, wait->iStatus); CleanupStack::PushL(opert); wait->Start(); User::LeaveIfError(opert->iStatus.Int()); // Check result TPckgBuf<TMsvLocalOperationProgress> progressPack; progressPack.Copy(opert->ProgressL()); TMsvLocalOperationProgress progress = progressPack(); User::LeaveIfError(progress.iError); CleanupStack::PopAndDestroy(2); // opert, wait // Get CMsvEntry for new entry TMsvId forwardId=progress.iId; cEntry->SetEntryL(forwardId); // Populate new forwarded message with Body text if(aPartList&KMsvMessagePartBody) { CMsvStore* store=cEntry->EditStoreL(); CleanupStack::PushL(store); StoreBodyL(*store); // Current context is original message store->CommitL(); CleanupStack::PopAndDestroy(); // store } CleanupStack::PopAndDestroy(); // cEntry // Request was performed synchronously, so return a completed operation object return CMsvCompletedOperation::NewL(Session(), KUidMsgTypeText, progressPack, KMsvNullIndexEntryId, aCompletionStatus); }
// ----------------------------------------------------------------------------- // CWPMessage::StoreMsgL // ----------------------------------------------------------------------------- // void CWPMessage::StoreMsgL() { FLOG( _L( "CWPMessage::StoreMsgL" ) ); // create an invisible blank entry TMsvEntry entry; PrepareEntryLC( entry ); // details on cleanup stack entry.iBioType = iBioUID.iUid; entry.iMtm = KUidBIOMessageTypeMtm; // Look up and set the description FLOG( _L( "CWPMessage::StoreMsgL 1" ) ); TInt index; CBIODatabase* bioDB = CBIODatabase::NewLC( iSession->FileSession() ); FLOG( _L( "CWPMessage::StoreMsgL 2" ) ); TRAPD( err, bioDB->GetBioIndexWithMsgIDL( iBioUID, index ) ); if (err ==KErrNone) { FLOG( _L( "CWPMessage::StoreMsgL 3" ) ); HBufC* description = bioDB->BifReader(index).Description().AllocL(); FLOG( _L( "CWPMessage::StoreMsgL 4" ) ); entry.iDescription.Set(*description); FLOG( _L( "CWPMessage::StoreMsgL 5" ) ); CleanupStack::PopAndDestroy(); // bioDB CleanupStack::PushL( description ); } else { FTRACE(RDebug::Print(_L(" CWPMessage::StoreMsgL err (%d)"), err)); CleanupStack::PopAndDestroy(); // bioDB } FLOG( _L( "CWPMessage::StoreMsgL 6" ) ); // Store entry in inbox CMsvEntry* msvEntry = iSession->GetEntryL( KMsvGlobalInBoxIndexEntryId ); FLOG( _L( "CWPMessage::StoreMsgL 7" ) ); CleanupStack::PushL(msvEntry); msvEntry->CreateL(entry); msvEntry->Session().CleanupEntryPushL(entry.Id()); msvEntry->SetEntryL(entry.Id()); FLOG( _L( "CWPMessage::StoreMsgL 8" ) ); // Save the message CMsvStore* store = msvEntry->EditStoreL(); CleanupStack::PushL(store); FLOG( _L( "CWPMessage::StoreMsgL 9" ) ); iMessage->StoreL( *store ); store->CommitL(); // Complete processing the message PostprocessEntryL( *msvEntry, entry ); CleanupStack::PopAndDestroy(); //store msvEntry->Session().CleanupEntryPop(); //entry CleanupStack::PopAndDestroy(3); //description, details, msvEntry FLOG( _L( "CWPMessage::StoreMsgL Done" ) ); }
// ----------------------------------------------------------------------------- // CWPMessage::StoreMsgL // ----------------------------------------------------------------------------- // void CWPMessage::StoreMsgL( TInt aResource ) { FLOG( _L( "CWPMessage::StoreMsgL(aResource)" ) ); // create an invisible blank entry TMsvEntry entry; PrepareEntryLC( entry ); // details on cleanup stack entry.iMtm = KUidMsgTypeSMS; // Store entry in inbox CMsvEntry* msvEntry = iSession->GetEntryL(KMsvGlobalInBoxIndexEntryId); CleanupStack::PushL(msvEntry); msvEntry->CreateL(entry); msvEntry->Session().CleanupEntryPushL(entry.Id()); msvEntry->SetEntryL(entry.Id()); // Save the message body CMsvStore* store = msvEntry->EditStoreL(); CleanupStack::PushL(store); CParaFormatLayer* paraFormat = CParaFormatLayer::NewL(); CleanupStack::PushL( paraFormat ); CCharFormatLayer* charFormat = CCharFormatLayer::NewL(); CleanupStack::PushL( charFormat ); CRichText* body = CRichText::NewL( paraFormat, charFormat ); CleanupStack::PushL( body ); HBufC* text = LoadStringLC( aResource ); body->InsertL( body->DocumentLength(), *text ); store->StoreBodyTextL( *body ); // Store the actual message for post-mortem analysis iMessage->StoreL( *store ); // Save the SMS header and create a description field CSmsHeader* header = CSmsHeader::NewL( CSmsPDU::ESmsDeliver, *body ); CleanupStack::PushL( header ); TBuf<KSmsDescriptionLength> description; CSmsGetDetDescInterface* smsPlugin = CSmsGetDetDescInterface::NewL(); CleanupStack::PushL( smsPlugin ); smsPlugin->GetDescription( header->Message(), description ); CleanupStack::PopAndDestroy( smsPlugin ); entry.iDescription.Set( description ); header->StoreL( *store ); store->CommitL(); CleanupStack::PopAndDestroy( 5 ); // header, text, body, charformat, paraFormat // Complete processing the message PostprocessEntryL( *msvEntry, entry ); CleanupStack::PopAndDestroy(); //store msvEntry->Session().CleanupEntryPop(); //entry CleanupStack::PopAndDestroy(2); //details, msvEntry }
LOCAL_C void TestSetSendingStateAttributeL() { CDummyObserver* ob = new(ELeave)CDummyObserver; CleanupStack::PushL(ob); CMsvSession* session = CMsvSession::OpenSyncL(*ob); CleanupStack::PushL(session); CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering()); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection; CleanupStack::PushL(selection); TMsvEntry entry1; entry1.iType = KUidMsvMessageEntry; entry1.iMtm = KUidMsvLocalServiceMtm; entry1.iServiceId = KMsvLocalServiceIndexEntryId; entry1.SetSendingState(12); cEntry->CreateL(entry1); selection->AppendL(entry1.Id()); TMsvEntry entry2; entry2.iType = KUidMsvMessageEntry; entry2.iMtm = KUidMsvLocalServiceMtm; entry2.iServiceId = KMsvLocalServiceIndexEntryId; entry2.SetSendingState(3); cEntry->CreateL(entry2); selection->AppendL(entry2.Id()); session->ChangeAttributesL(*selection, 6<<KMsvSendingStateShift, 0); cEntry->SetEntryL(entry1.Id()); test(cEntry->Entry().SendingState() == 6); cEntry->SetEntryL(entry2.Id()); test(cEntry->Entry().SendingState() == 6); CleanupStack::PopAndDestroy(4); // selection, cEntry, session, ob }
/* ----------------------------------------------------------------------------- RFile GetAttachmentFileL(TMsvAttachmentId aId) ---------------------------------------------------------------------------- */ void CMailBoxContainer::OpenFileL(TBool /*aOpenWith*/) { if(iSession && iSelectionBox) { TInt CurrItmIndex = iSelectionBox->CurrentItemIndex(); TMsvSelectionOrdering sort; sort.SetShowInvisibleEntries(ETrue); sort.SetSorting(EMsvSortByDate); // Take a handle to the folder entry CMsvEntry* parentEntry = CMsvEntry::NewL(*iSession,iCurrentMailBox,sort); CleanupStack::PushL(parentEntry); // A selection of all BT entries CMsvEntrySelection* entries = parentEntry->ChildrenL();//ChildrenWithMtmL(KUidMsgTypeBt); CleanupStack::PushL(entries); //Process all entries if(CurrItmIndex >= 0 && CurrItmIndex < iIDArray->Count()) { //Get entry CMsvEntry* btEntry = iSession->GetEntryL(iIDArray->At(CurrItmIndex).iEnt); CleanupStack::PushL(btEntry); //Then get entrys child CMsvEntrySelection* btChildren = btEntry->ChildrenL(); CleanupStack::PushL(btChildren); btEntry->SetEntryL(iIDArray->At(CurrItmIndex).iMsg); if (btEntry->HasStoreL()) { CMsvStore* store = btEntry->ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& attMngr = store->AttachmentManagerL(); CMsvAttachment* attachment = attMngr.GetAttachmentInfoL(iIDArray->At(CurrItmIndex).iAtt); if(attachment) { RFile SourceFil(attMngr.GetAttachmentFileL(iIDArray->At(CurrItmIndex).iAtt)); iUtils.GetFileUtils().OpenFileWithHandler(SourceFil); SourceFil.Close(); } CleanupStack::PopAndDestroy(store); } CleanupStack::PopAndDestroy(2); } CleanupStack::PopAndDestroy(2); } }
void CMtfTestActionCreateEntry::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCreateEntry); CActiveScheduler::Add(this); iBlank = KNullDesC().AllocL(); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TUid paramEntryTypeUid = ObtainValueParameterL<TUid>(TestCase(),ActionParameters().Parameter(1)); TMsvId paramParentId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2)); TUid paramMtmUid = ObtainValueParameterL<TUid>(TestCase(),ActionParameters().Parameter(3), KUidMsvLocalServiceMtm); TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(4), KMsvLocalServiceIndexEntryId); TMsvPriority paramPriority = ObtainValueParameterL<TMsvPriority>(TestCase(),ActionParameters().Parameter(5),EMsvMediumPriority); TInt paramReadOnlyFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(6),EFalse); TInt paramVisibleFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(7),ETrue); HBufC* paramDescription = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(8),iBlank); HBufC* paramDetails = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(9),iBlank); iIndexEntry.iType = paramEntryTypeUid; iIndexEntry.iMtm = paramMtmUid; iIndexEntry.iServiceId = paramServiceId; iIndexEntry.SetPriority(paramPriority); iIndexEntry.SetReadOnly(paramReadOnlyFlag); iIndexEntry.SetVisible(paramVisibleFlag); iIndexEntry.iDescription.Set(paramDescription->Des()); iIndexEntry.iDetails.Set(paramDetails->Des()); iIndexEntry.iDate.HomeTime(); CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramParentId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(paramParentId); if (entry->OwningService() == KMsvLocalServiceIndexEntryId) { entry->CreateL(iIndexEntry); CleanupStack::PopAndDestroy(entry); TMsvId paramEntryId; paramEntryId = iIndexEntry.Id(); StoreParameterL<TMsvId>(TestCase(),paramEntryId,ActionParameters().Parameter(10)); TestCase().ActionCompletedL(*this); } else { iOperation = entry->CreateL(iIndexEntry,iStatus); SetActive(); } TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCreateEntry); }
/** CountLinesOfBodyTextL() Counts the lines of body text in the email aEntry @param aEntry A reference to an object representing the email @param aFooterExists Reference to a boolean variable - set to ETrue if the footer string is found in the body text @param aFooterSize Expected KB left on server inserted into footer string if present @return Number of lines in the body text */ TInt CT_MsgComparePopEmailMsgs::CountLinesOfBodyTextL(CMsvEntry& aEntry, TBool& aFooterExists, TInt& aFooterSize) { TInt lines = 0; aFooterExists=EFalse; aFooterSize=0; aEntry.SetEntryL(aEntry.EntryId()); if(aEntry.HasStoreL()) { CMsvStore* msvStore1= aEntry.ReadStoreL(); CleanupStack::PushL(msvStore1); CParaFormatLayer* paraFormatLayer1 = CParaFormatLayer::NewL(); CleanupStack::PushL(paraFormatLayer1); CCharFormatLayer* charFormatLayer1 = CCharFormatLayer::NewL(); CleanupStack::PushL(charFormatLayer1); CRichText* bodyText1=CRichText::NewL(paraFormatLayer1, charFormatLayer1, CEditableText::EFlatStorage, 256); CleanupStack::PushL(bodyText1); bodyText1->Reset(); if (msvStore1->HasBodyTextL()) { msvStore1->RestoreBodyTextL(*bodyText1); TUint16 val = CEditableText::ELineBreak; TInt n = 0; TInt pos = 0; for(;;) { TPtrC bodyText = bodyText1->Read(pos); n = bodyText.Find(&val, 1); if(n < 0) break; lines++; pos += n+1; //This Check is needed to delete the extra line introduced by communigate Pro Server TInt fpos = CheckIfServerMessageExists(bodyText); if (fpos != KErrNotFound) { lines--; } } TPtrC pBt = bodyText1->Read(0); aFooterExists = CheckIfFooterMessageExistsL(pBt , aFooterSize); } CleanupStack::PopAndDestroy(4, msvStore1); //bodyText1,charFormatLayer1,paraFormatLayer1,msvStore1. } return lines; }
LOCAL_C void TestEntryStream(CMsvEntry& aEntry, TMsvId aId, TMsvId aService, TBool aAllDescendents) { // get the store aEntry.SetEntryL(aId); CMsvStore* store=NULL; if(aEntry.HasStoreL()) store = aEntry.ReadStoreL(); test(store==NULL || store->IsPresentL(KUidMsvHiddenEntryStream)==EFalse); delete store; // recurse into the children if (aAllDescendents) { CMsvEntrySelection* selection = aEntry.ChildrenL(); TInt count=selection->Count(); while (count--) TestEntryStream(aEntry, selection->At(count), aService, EFalse); delete selection; } }
TBool CSmsReplyToStep::CheckMessageL() { INFO_PRINTF1(_L("Received new message in Inbox - should be status report...")); TMsvSelectionOrdering ordering; ordering.ShowInvisibleEntries(); CMsvEntry* entry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId,ordering); CleanupStack::PushL(entry); CMsvEntrySelection* msvEntrySelection; msvEntrySelection=entry->ChildrenL(); CleanupStack::PushL(msvEntrySelection); // Check how many mesasges there are - should be just 1 TInt count = msvEntrySelection->Count(); INFO_PRINTF3(_L("Number of new messages: %d, should be: %d"), count, 1); // Restore the message CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iTestUtils->iRichText); CleanupStack::PushL(header); entry->SetEntryL((*msvEntrySelection)[0]); CMsvStore* store = entry->ReadStoreL(); CleanupStack::PushL(store); header->RestoreL(*store); if(store->HasBodyTextL()) { store->RestoreBodyTextL(*iTestUtils->iRichText); } TBuf<KSmsDescriptionLength> desc; User::LeaveIfError(TSmsUtilities::GetDescription(header->Message(), desc)); //Check for a reply address field CSmsReplyAddressOperations& operations = STATIC_CAST(CSmsReplyAddressOperations&,header->Message().GetOperationsForIEL(CSmsInformationElement::ESmsReplyAddressFormat)); TBool result=operations.ContainsReplyAddressIEL(); CleanupStack::PopAndDestroy(4,entry); return result; }
/** Stores the Unknown Push message in the message store. Saves the message data in a new attachment file. This makes it more efficient for the UI to read the data. @param aSession Message server session @param aParent ID of the parent for the new entry. It is the caller's responsibility to ensure that the parent ID is correct. @return ID of the new message server entry. @see CPushMsgEntryBase::SaveL() */ EXPORT_C TMsvId CUnknownPushMsgEntry::SaveL(CMsvSession& aSession, TMsvId aParent) { CMsvEntry* entryPtr = aSession.GetEntryL(KMsvRootIndexEntryId); CleanupStack::PushL(entryPtr); // This tidies itself up TMsvId newEntry = CPushMsgEntryBase::SaveL(aSession, aParent); #ifdef __MESSAGING_API_V2__ TRAPD( saveError, TFileName fileName = ContentFileNameL(); entryPtr->SetEntryL(newEntry); CMsvStore* store = entryPtr->EditStoreL(); CleanupStack::PushL(store); SaveMessageBodyL(store->AttachmentManagerL(), fileName); store->CommitL(); CleanupStack::PopAndDestroy(store); )
void CMtfTestActionGetEntry::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionAddGetEntry); if(TestCase().TestStepResult() == EPass) { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); entry->SetEntryL(messageEntry); StoreParameterL<CMsvEntry>(TestCase(),*entry,ActionParameters().Parameter(2)); CleanupStack::Pop(entry); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionAddGetEntry); } TestCase().ActionCompletedL(*this); }
void CT_CMsvSession::TestTransferCommandL() { TInt error = KErrGeneral; INFO_PRINTF1(_L("Testing: Transfer Commands -- started")); TRAP(error, iSession = CMsvSession::OpenSyncL(*this)); TEST(error == KErrNone); CMsvOperationWait* active = CMsvOperationWait::NewLC(); CMsvEntry* cEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering()); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection; CleanupStack::PushL(selection); TInt ret = iSession->InstallMtmGroup(KDataComponentFilename); TEST(ret==KErrNone|| ret==KErrAlreadyExists); cEntry->SetEntryL(KMsvRootIndexEntryId); TMsvEntry service; service.iType=KUidMsvServiceEntry; service.iMtm = KUidTestServerMtmType; cEntry->CreateL(service); selection->AppendL(service.Id()); TBuf8<256> progress; TBuf8<32> param; CMsvOperation* operation = NULL; active->Start(); operation = iSession->TransferCommandL(*selection, 1, param, active->iStatus); CActiveScheduler::Start(); TEST(operation->iStatus.Int()==KErrNone); cEntry->DeleteL(service.Id()); delete operation; CleanupStack::PopAndDestroy(selection); CleanupStack::PopAndDestroy(cEntry); CleanupStack::PopAndDestroy(active); delete iSession; INFO_PRINTF1(_L("Testing: Transfer Commands -- ended")); }
// ----------------------------------------------------------------------------- // CMmsAdapterMsvApi::DeleteUserFolderL // ----------------------------------------------------------------------------- // TInt CMmsAdapterMsvApi::DeleteUserFolderL( TMsvId aUid ) { TRACE_FUNC_ENTRY; CMsvEntry* entry = iSession.GetEntryL(aUid); CleanupStack::PushL(entry); TMsvEntry tEntry = entry->Entry(); TMsvId parent = tEntry.Parent(); if ( tEntry.iType != KUidMsvFolderEntry || parent != KMsvMyFoldersEntryIdValue ) { LOGGER_WRITE( "Not correct folder" ); CleanupStack::PopAndDestroy(entry); LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" ); return KErrNotSupported; } CMsvEntrySelection* children = entry->ChildrenL(); TInt count = children->Count(); delete children; if ( count > 0 ) { LOGGER_WRITE( "Folder not empty" ); CleanupStack::PopAndDestroy( entry ); LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" ); return KErrInUse; } tEntry.SetReadOnly( EFalse ); entry->ChangeL( tEntry ); entry->SetEntryL( parent ); entry->DeleteL( aUid ); CleanupStack::PopAndDestroy( entry ); TRACE_FUNC_EXIT; return KErrNone; }
/** CountLinesOfHtmlL() Counts the number of lines of HTML @param aEntry A reference to an object representing the email @return Number of lines of HTML */ TInt CT_MsgComparePopEmailMsgs::CountLinesOfHtmlL(CMsvEntry& aEntry) { TInt lines = 0; aEntry.SetEntryL(aEntry.EntryId()); CMsvStore* store = aEntry.ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& attManager = store->AttachmentManagerL(); RFile htmlFile = attManager.GetAttachmentFileL(0); CleanupClosePushL(htmlFile); _LIT8(KFindData, "\r\n"); TInt htmlSize = 0; User::LeaveIfError(htmlFile.Size(htmlSize)); HBufC8* fBuf = HBufC8::NewLC(htmlSize); TPtr8 p = fBuf->Des(); htmlFile.Read(p); TInt pos = 0; for(;;) { pos = p.Find(KFindData); if(pos < 0) { break; } p = p.Mid(pos+2); lines++; } CleanupStack::PopAndDestroy(fBuf); CleanupStack::PopAndDestroy(); // htmlFile CleanupStack::PopAndDestroy(store); return lines; }
/** GetMessageLinesL() Counts the number of lines in a message's HTML or body text @param aEntry Email message identifier @param aUid Request identifier KUidMsvEmailHtmlEntry or KUidMsvEmailTextEntry at present @param aFooterExists Reference to a boolean variable only used when aUid == KUidMsvEmailTextEntry @param aFooterSize Expected KB left on server inserted into footer string if present @return Returns the number of lines in the requested message part */ TInt CT_MsgComparePopEmailMsgs::GetMessageLinesL(TMsvEntry& aEntry, TUid aUid, TBool& aFooterExists, TInt &aFooterSize) { TInt lines = 0; TMsvId msgPartIndex = GetMessagePartIndexL(aEntry,aUid); if(msgPartIndex) { CMsvEntry* msvEntry = iSharedDataPOP.iSession->GetEntryL(msgPartIndex); CleanupStack::PushL(msvEntry); msvEntry->SetEntryL(msgPartIndex); if(aUid == KUidMsvEmailTextEntry) { lines = CountLinesOfBodyTextL(*msvEntry, aFooterExists, aFooterSize); } else if(aUid == KUidMsvEmailHtmlEntry) { lines = CountLinesOfHtmlL(*msvEntry); } CleanupStack::PopAndDestroy(msvEntry); } return lines; }
//--------------------------------------------------------------- // TestUniDataModelPlugin::createMMS //--------------------------------------------------------------- void TestUniDataModelMMSPlugin::createMMS(TMsvId pId, TBool subjectField) { TMsvEntry indexEntry; indexEntry.iType = KUidMsvMessageEntry; indexEntry.iMtm = KUidMsgTypeMultimedia; indexEntry.iServiceId = iServiceId; indexEntry.iDate.HomeTime(); // Convert TTime to QDateTime , this will be used for comparing the time of mesage // when fetched from datamodel TTime unixEpoch(KUnixEpoch); TTimeIntervalSeconds seconds; TTime timeStamp = indexEntry.iDate; timeStamp.SecondsFrom(unixEpoch, seconds); retTimeStamp.setTime_t(seconds.Int()); TMsvId parentId = pId; CMsvEntry* entry = CMsvEntry::NewL(*iMSession,parentId,TMsvSelectionOrdering()); CleanupStack::PushL(entry); entry->SetEntryL(parentId); entry->CreateL(indexEntry); entry->SetEntryL(indexEntry.Id()); iMmsClientMtm->SwitchCurrentEntryL(entry->EntryId()); CMsvStore* store = iMmsClientMtm->Entry().EditStoreL(); CleanupStack::PushL(store); //MMS Message ID Saved iMessageId = indexEntry.Id(); //Adding Subject if(subjectField) { QString subject(TEST_MSG_SUBJECT); HBufC* subj = XQConversions::qStringToS60Desc(subject); iMmsClientMtm->SetSubjectL(*subj); } //Adding Sender QString sender(TEST_MSG_FROM1); HBufC* addr = XQConversions::qStringToS60Desc(sender); if (addr) { CleanupStack::PushL(addr); TBuf<32> name; name.Copy(addr->Left(32)); indexEntry.iDetails.Set(name); iMmsClientMtm->SetSenderL(*addr); CleanupStack::PopAndDestroy(addr); } //Adding Recipient QString recipient(TEST_MSG_RECIEPIENT1); HBufC* addr2 = XQConversions::qStringToS60Desc(recipient); if (addr2) { CleanupStack::PushL(addr2); iMmsClientMtm->AddAddresseeL(EMsvRecipientTo,*addr2); CleanupStack::PopAndDestroy(addr2); } //Adding cCRecipient QString recipient2(TEST_MSG_RECIEPIENT2); HBufC* addr3 = XQConversions::qStringToS60Desc(recipient2); if (addr3) { CleanupStack::PushL(addr3); iMmsClientMtm->AddAddresseeL(EMsvRecipientCc,*addr3); CleanupStack::PopAndDestroy(addr3); } //Adding bCCRecipient QString recipient3(TEST_MSG_RECIEPIENT3); HBufC* addr4 = XQConversions::qStringToS60Desc(recipient3); if (addr4) { CleanupStack::PushL(addr4); iMmsClientMtm->AddAddresseeL(EMsvRecipientBcc,*addr4); CleanupStack::PopAndDestroy(addr4); } //Create Text Attachment TMsvAttachmentId attaId = 0; TFileName attachmentFile( _L("story.txt") ); TBufC<12> story = _L( "Hello world!" ); iMmsClientMtm->CreateTextAttachmentL(*store, attaId, story, attachmentFile, ETrue ); qDebug() << "Text Attachment id" << attaId; //Image Attachment added to the message entry RFile attaFile; // Set filename of attachment TFileName name( KPictureFileName ); CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL(); CleanupStack::PushL( mimeHeaders ); // Set values to mime headers mimeHeaders->SetContentTypeL( _L8( "image") ); mimeHeaders->SetContentSubTypeL( _L8( "jpeg" ) ); _LIT8(KMimeType, "image/jpeg"); TBufC8<10> mimeType(KMimeType); // CreateAttachment2L will set the content type to attachment Info // Open the attachment file for reading attaFile.Open( iFs, name, EFileShareReadersOnly | EFileRead ); CleanupClosePushL(attaFile); CMsvAttachment* attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); // attaInfo ownerhip will be transferred to Attachment Manager. // It must not be pushed onto the cleanupStack before calling // CreateAttachment2L. iMmsClientMtm->CreateAttachment2L(*store, attaFile,mimeType,*mimeHeaders,attaInfo,attaId); qDebug() << "Image Attachment id" << attaId; // Now Attachment Manager owns the attaInfo CleanupStack::Pop(); // attaFile.Close() CleanupStack::PopAndDestroy(); // mimeHeaders store->CommitL(); CleanupStack::PopAndDestroy(store); // store iMmsClientMtm->SaveMessageL(); //Saving the message size for future checking msgSize = iMmsClientMtm->MessageSize(); CleanupStack::Pop(entry); // entry }
/** LoadParametersL() Loads the test parameters @leave KErrNotReady @return ETrue if parameters loaded, Efalse on failure. */ TBool CT_MsgComparePopEmailMsgs::LoadParametersL() { TPtrC sentFolder; _LIT(KSentFolder, "SentFolder"); if(!GetStringFromConfig(ConfigSection(), KSentFolder, sentFolder)) { ERR_PRINTF1(_L("No Input for Sent Folder")); User::Leave(KErrNotReady); } iSentSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, CT_MsgUtilsEnumConverter::FindFolderIdByName(sentFolder)); if(! iSentSelectionList) { ERR_PRINTF1(_L("Invalid sentSelectionList")); SetTestStepResult(EFail); return EFalse; } TPtrC inboxFolder; _LIT(KInboxFolder, "InboxFolder"); if(!GetStringFromConfig(ConfigSection(), KInboxFolder, inboxFolder)) { ERR_PRINTF1(_L("No Input for Inbox Folder")); User::Leave(KErrNotReady); } TPtrC popAccountName; if(!GetStringFromConfig(ConfigSection(), KPopAccountName, popAccountName)) { ERR_PRINTF1(_L("Account name not specified")); SetTestStepResult(EFail); } if (CT_MsgUtilsEnumConverter::FindFolderIdByName(inboxFolder) == KMsvLocalServiceIndexEntryId) { // We are expecting to get a selection of remote Folder(which is the serviceId) TMsvId popServiceId = CT_MsgUtilsCentralRepository::GetPopServiceIdL((TDes&)popAccountName); CMsvEntry* entry = iSharedDataPOP.iSession->GetEntryL(popServiceId); CleanupStack::PushL(entry); entry->SetEntryL(popServiceId); // Setting the context to remote folder. iInboxSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, popServiceId); CleanupStack::PopAndDestroy(entry); } else { iInboxSelectionList = CT_MsgUtils ::CreateChildrenSelectionL(iSharedDataPOP.iSession, CT_MsgUtilsEnumConverter::FindFolderIdByName(inboxFolder)); } if(! iInboxSelectionList) { ERR_PRINTF1(_L("Invalid inboxSelectionList")); SetTestStepResult(EFail); return EFalse; } //Starting the comparision if(iInboxSelectionList->Count() != iSentSelectionList->Count()) { ERR_PRINTF3(_L("iInboxSelectionList->Count(%d) != iSentSelectionList->Count(%d)"), iInboxSelectionList->Count(), iSentSelectionList->Count()); SetTestStepResult(EFail); return EFalse; } TInt comInt = -1; _LIT(KNumTest, "NumTest"); if (!GetIntFromConfig(ConfigSection(), KNumTest, comInt)) { ERR_PRINTF1(_L("No Input for NumTests")); User::Leave(KErrNotReady); } TInt numTests = comInt; if(numTests != iInboxSelectionList->Count()) { ERR_PRINTF1(_L("iNumTests != iInboxSelectionList")); SetTestStepResult(EFail); return EFalse; } iExpResults.Reset(); for(TInt i = 0;i < numTests; i++) { CExpPop3MailInfo* pExp = GetExpPop3MailInfoLC(i); if(! pExp) { ERR_PRINTF1(_L("Invalid expected mail Info")); SetTestStepResult(EFail); return EFalse; } else { CleanupStack::Pop(pExp); // pExp iExpResults.Append(pExp); } } return ETrue; }
/** CountLinesOfBodyTextL() Counts the lines of body text in the email aEntry @param aEntry A reference to an object representing the email @param aFooterExists Reference to a boolean variable - set to ETrue if the footer string is found in the body text @param aFooterSize Expected KB left on server inserted into footer string if present @return Number of lines in the body text */ TInt CT_MsgComparePopEmailMsgs::CountLinesOfBodyTextL(CMsvEntry& aEntry, TBool& aFooterExists, TInt& aFooterSize) { TInt lines = 0; TInt count =0; aFooterExists=EFalse; aFooterSize=0; aEntry.SetEntryL(aEntry.EntryId()); if(aEntry.HasStoreL()) { CMsvStore* msvStore1= aEntry.ReadStoreL(); CleanupStack::PushL(msvStore1); CParaFormatLayer* paraFormatLayer1 = CParaFormatLayer::NewL(); CleanupStack::PushL(paraFormatLayer1); CCharFormatLayer* charFormatLayer1 = CCharFormatLayer::NewL(); CleanupStack::PushL(charFormatLayer1); CRichText* bodyText1=CRichText::NewL(paraFormatLayer1, charFormatLayer1, CEditableText::EFlatStorage, 256); CleanupStack::PushL(bodyText1); bodyText1->Reset(); if (msvStore1->HasBodyTextL()) { msvStore1->RestoreBodyTextL(*bodyText1); TUint16 val = CEditableText::ELineBreak; TUint16 val1 = CEditableText::EParagraphDelimiter; TUint16 val2 = KUnicodeValue; TInt n = 0; TInt pos = 0; for(;;) { TPtrC bodyText = bodyText1->Read(pos); n = bodyText.Find(&val, 1); // if iStore8BitData flag is set, the line is terminated by "CEditableText::EParagraphDelimiter" if(msvStore1->IsPresentL(KMsvPlainBodyText8)) { if ( 0 == count ) { TPtrC buffer = bodyText.Mid(0,n+2); // eg for 8bit the body look as : This is a simple email message.\x2028\x2029\x2029 // eg for 16bit the body look as: This is a simple email message.\x2028\x2028\x2029 if((bodyText.Right(2).Compare(KParagraphDelimiter)==KErrNone) && \ buffer.Find(&val2,1) != 75) { lines++; count++; } // Increment the line if EParagraphDelimiter or 0x0046 is found sequence as eg:1. \x2028\x2029 // 2. \x2028\x2029\x2028\x2029\x0046 3. \x2028\x2029\x2028\x2029\x2028\x2029 else if ( (buffer.Find(&val1,1)==0 && n==-1) || (buffer.Find(&val2,1)==1) \ || (buffer.Find(&val1,1)>0) ) { lines++; } } } if(n < 0) break; lines++; pos += n+1; //This Check is needed to delete the extra line introduced by communigate Pro Server TInt fpos = CheckIfServerMessageExists(bodyText); if (fpos != KErrNotFound) { lines--; } } TPtrC pBt = bodyText1->Read(0); aFooterExists = CheckIfFooterMessageExistsL(pBt , aFooterSize); } CleanupStack::PopAndDestroy(4, msvStore1); //bodyText1,charFormatLayer1,paraFormatLayer1,msvStore1. } return lines; }