void CAddObexAttachmentAsEntryState::StartL(TRequestStatus& aStatus)
{
// Add an attachment as a child entry
CBaseMtm& clientMtm = iClientTest.ObexTestUtils().GetCurrentObexClientMtm();
CMsvEntry& entry = clientMtm.Entry();
CMsvStore* store = entry.EditStoreL();
CleanupStack::PushL(store);
CAsyncWaiter* waiter = CAsyncWaiter::NewL();
CleanupStack::PushL(waiter);
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachment);
TParse fileNameParser;
User::LeaveIfError(fileNameParser.Set(iFileName, NULL, NULL));
attachment->SetAttachmentNameL(fileNameParser.NameAndExt());
store->AttachmentManagerL().AddAttachmentL(iFileName, attachment, waiter->iStatus);
CleanupStack::Pop(attachment);
waiter->StartAndWait();
User::LeaveIfError(waiter->Result());
CleanupStack::PopAndDestroy(waiter);
store->CommitL();
CleanupStack::PopAndDestroy(store);
TRequestStatus* status = &aStatus;
User::RequestComplete(status, KErrNone);
}
// ----------------------------------------------------------------------------
// CIpsPlgNewChildPartFromFileOperation::InitAttachmentManagerL
// ----------------------------------------------------------------------------
//
void CIpsPlgNewChildPartFromFileOperation::InitAttachmentManagerL()
{
iEntry = NULL;
iMessage = NULL;
RFile file;
TInt fileSize( 0 );
// Read attachment size
User::LeaveIfError(
file.Open( iMsvSession.FileSession(), iFilePath->Des(), EFileShareReadersOnly )
);
//in rare case that file has disappeared while sending
//we just won't get the size for it
file.Size( fileSize );
file.Close();
// Initialize CMsvAttachment instance for the attachment creation
CMsvAttachment* info = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
CleanupStack::PushL( info );
info->SetAttachmentNameL( iFilePath->Des() );
info->SetSize( fileSize );
// Create/acquire Symbian message entry objects
GetMessageEntryL( iMessageId.Id(), iEntry, iMessage );
// Start attachment creation
iMessage->AttachmentManager().AddAttachmentL(
iFilePath->Des(), info, iStatus );
CleanupStack::Pop( info ); // attachment manager takes ownership
iStep = EPrepareMsvEntry; // Next step
SetActive();
}
void CMtfTestActionAddAttachmentAsLink::RunTestL()
{
CMsvStore* paramStore = ObtainParameterReferenceL<CMsvStore>(TestCase(),ActionParameters().Parameter(0));
HBufC* paramFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(1));
HBufC8* paramMimeType = ObtainParameterReferenceL<HBufC8>(TestCase(),ActionParameters().Parameter(2));
CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL();
CleanupStack::PushL(waiter);
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile);
CleanupStack::PushL(attachment);
attachment->SetMimeTypeL(*paramMimeType);
TParse fileNameParser;
User::LeaveIfError(fileNameParser.Set(*paramFilePath, NULL, NULL));
attachment->SetAttachmentNameL(fileNameParser.NameAndExt());
MMsvAttachmentManager& manager = paramStore->AttachmentManagerL();
manager.AddLinkedAttachmentL(*paramFilePath, attachment, waiter->iStatus);
CleanupStack::Pop(attachment); // ownership passed to manager
waiter->StartAndWait();
User::LeaveIfError(waiter->Result());
CleanupStack::PopAndDestroy(waiter);
TMsvAttachmentId attachmentId = attachment->Id();
paramStore->CommitL();
StoreParameterL<TMsvAttachmentId>(TestCase(),attachmentId,ActionParameters().Parameter(3));
}
void CMtfTestActionSmtpAddLinkedAttachment::RunTestL()
{
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
HBufC* paramFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(2));
HBufC8* paramMimeType = ObtainParameterReferenceL<HBufC8>(TestCase(),ActionParameters().Parameter(3));
CMsvEntry* entry = paramSession->GetEntryL(messageEntry);
CleanupStack::PushL(entry);
CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry);
CleanupStack::PushL(emailMsg);
CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL();
CleanupStack::PushL(waiter);
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile);
CleanupStack::PushL(attachment);
attachment->SetMimeTypeL(*paramMimeType);
TParse fileNameParser;
User::LeaveIfError(fileNameParser.Set(*paramFilePath, NULL, NULL));
attachment->SetAttachmentNameL(fileNameParser.NameAndExt());
TEntry fileEntry;
User::LeaveIfError(paramSession->FileSession().Entry( fileNameParser.FullName(), fileEntry));
attachment->SetSize(fileEntry.iSize);
MMsvAttachmentManager& manager = emailMsg->AttachmentManager();
manager.AddLinkedAttachmentL(*paramFilePath, attachment, waiter->iStatus);
CleanupStack::Pop(attachment); // ownership passed to manager
waiter->StartAndWait();
User::LeaveIfError(waiter->Result());
CleanupStack::PopAndDestroy(waiter);
attachment = NULL;
TInt attachmentCount = manager.AttachmentCount();
attachment = manager.GetAttachmentInfoL(attachmentCount - 1);
CleanupStack::PushL(attachment);
TMsvAttachmentId attachmentId = attachment->Id();
CleanupStack::PopAndDestroy(attachment);
CleanupStack::PopAndDestroy(2, entry); // emailMsg, entry
StoreParameterL<TMsvAttachmentId>(TestCase(),attachmentId,ActionParameters().Parameter(4));
}
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
}
EXPORT_C void CSmtpClientMtm::AddLinkedAttachmentL(const TDesC& aFilePath, const TDesC8& aMimeType, TUint aCharset, TRequestStatus& aStatus)
{
__ASSERT_DEBUG(iMsvEntry->Entry().iType.iUid==KUidMsvMessageEntryValue, gPanic(ESmtcMTMNotAMessageEntry));
if( iAttachmentWaiter == NULL )
{
iAttachmentWaiter = CImAttachmentWaiter::NewL();
}
if (iEmailMessage == NULL)
{
iEmailMessage = CImEmailMessage::NewL(*iMsvEntry);
}
else if (iEmailMessage->EmailEntryId() != iMsvEntry->EntryId())
{
delete iEmailMessage;
iEmailMessage = NULL;
iEmailMessage = CImEmailMessage::NewL(*iMsvEntry);
}
CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile);
CleanupStack::PushL(attachmentInfo);
attachmentInfo->SetMimeTypeL(aMimeType);
TParse fileNameParser;
User::LeaveIfError(fileNameParser.Set(aFilePath, NULL, NULL));
attachmentInfo->SetAttachmentNameL(fileNameParser.NameAndExt());
if( aCharset!=0 )
{
CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC();
headers->SetMimeCharset(aCharset);
headers->StoreL(*attachmentInfo);
CleanupStack::PopAndDestroy(headers);
}
iEmailMessage->AttachmentManager().AddLinkedAttachmentL(aFilePath, attachmentInfo, iAttachmentWaiter->iStatus);
CleanupStack::Pop(attachmentInfo);// ownership passed to attachment manager
iAttachmentWaiter->StartWaitingL(aStatus, iEmailMessage, EFalse);
}
//
// StoreL() - Store bookmarks as an attachment file
// in the .eBM format. If the system runs out of memory while
// the bookmarks are being written to the file, the file will be
// deleted. For example, if 2 bookmarks have already been written
// to the file, and the writing of the third bookmark fails, the
// file will be deleted. Otherwise, a failure of file writing would
// need to be handled differently from memory allocation failure.
//
void CWWWHotlistParser::StoreL(CMsvEntry& aEntry)
{
TInt numberOfItems = iHotlistItemList->Count();
if (numberOfItems>0) // Only create a file if there is something to save!
{
// Generate fileName from msgId and bookmark file extension.
// The file name consists of the msgId in hex format
// followed by .eBM. Sizeof operator returns the size of msgId
// in bytes and each byte requires 2 hex digits to represent it,
// hence sizeof is multipled by 2. Didn't want to make
// fileNameLength constant because the size of TMsvId may change
// in the future.
TMsvId entryId = aEntry.Entry().Id();
TInt fileNameLength = 2*sizeof(entryId) +
KEBookmarkExtension().Length();
HBufC *fileName = HBufC::NewLC(fileNameLength);
TPtr fileNameDes = fileName->Des();
// The file name uses the hex representation of the entry Id.
// If this changes to some other representation then
// fileNameLength will need to be calculated differently.
fileNameDes.Num(entryId,EHex);
fileNameDes.Append(KEBookmarkExtension);
// Get the attachment manager and create an empty attachment file
CMsvStore* store = aEntry.EditStoreL();
CleanupStack::PushL(store);
MMsvAttachmentManagerSync& managerSync = store->AttachmentManagerExtensionsL();
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachment);
attachment->SetAttachmentNameL(*fileName);
RFile file;
managerSync.CreateAttachmentL(*fileName, file, attachment);
CleanupStack::Pop(attachment); // ownership passed
CleanupClosePushL(file);
#ifdef SYMBIAN_BOOKMARK_DATABASE
// Open the bookmark database ready to add the bookmarks
RBkDatabase bookmarkDb;
bookmarkDb.OpenL();
CleanupClosePushL(bookmarkDb);
#endif // SYMBIAN_BOOKMARK_DATABASE
// Stream each bookmark into the file.
// The eBookmark file must contain only 8bit ascii.
// Add a linefeed to the end of each line.
for(TInt count=0; count < numberOfItems; count++)
{
CWWWHotlistItem &item = *iHotlistItemList->At(count);
// Allocate enough space to hold the full bookmark entry.
TInt length = item.Name().Length() +
item.Url().Length() +
KEBookmarkConstantChars;
HBufC8 *writeBuf = HBufC8::NewLC(length);
TPtr8 des = writeBuf->Des();
des.Append(KEBookmarkItemBegin);
des.Append(KEBookmarkItemURL);
des.Append(item.Url());
des.Append(KCRLinefeed);
des.Append(KEBookmarkItemName);
des.Append(item.Name());
des.Append(KCRLinefeed);
des.Append(KEBookmarkType);
des.Append(KEBookmarkItemEnd);
User::LeaveIfError(file.Write(des));
CleanupStack::PopAndDestroy();
#ifdef SYMBIAN_BOOKMARK_DATABASE
// Add the bookmark to the bookmark database
RBkBookmark bookmark = bookmarkDb.CreateBookmarkL();
CleanupClosePushL(bookmark);
bookmark.SetTitleL(item.Name());
// Convert Uri to 8-bit
HBufC8* bookmarkUri = HBufC8::NewLC(item.Url().Length());
bookmarkUri->Des().Copy(item.Url());
bookmark.SetUriL(*bookmarkUri);
CleanupStack::PopAndDestroy(2, &bookmark); // bookmarkUri, bookmark
#endif // SYMBIAN_BOOKMARK_DATABASE
}
#ifdef SYMBIAN_BOOKMARK_DATABASE
// Commit all the added bookmarks and close bookmark db
bookmarkDb.CommitL();
CleanupStack::PopAndDestroy(&bookmarkDb);
#endif // SYMBIAN_BOOKMARK_DATABASE
// File writing has completed, set the size in the attachment
TInt fileSize = 0;
User::LeaveIfError(file.Size(fileSize));
attachment->SetSize(fileSize);
// commit the changes
store->CommitL();
CleanupStack::PopAndDestroy(3, fileName); // file, store, fileName
}
}
// ---------------------------------------------------------
// CMmsAttachmentHandler::CreateUTF8TextAttachmentFromFileL
// ---------------------------------------------------------
EXPORT_C void CMmsAttachmentHandler::CreateUTF8TextAttachmentFromFileL(
CMsvStore& aStore,
TMsvAttachmentId& aAttachmentId,
RFile& aFile,
RFs& aFs,
TDriveUnit aMessageDrive )
{
_LIT8 ( KMmsCrLf8, "\x00D\x00A" ); // 8 bit line feed
TInt size = 0;
TInt error = KErrNone;
error = aFile.Size( size );
User::LeaveIfError( error ); // if can't get file size, we are in trouble
TFileName* filename = new( ELeave ) TFileName;
CleanupStack::PushL( filename );
// 256 characters for each read
HBufC* textBuffer = HBufC::NewL( KMmsTextBufferSize );
CleanupStack::PushL( textBuffer );
TPtr textPtr = textBuffer->Des();
HBufC8* buffer = HBufC8::NewL( KMmsTextBufferSize * KMmsMaxBytesPerCharacter ); // paranoid.
TInt fileSize = 0; // we don't know how big the file will be after conversion
CleanupStack::PushL( buffer );
TPtr8 buf8 = buffer->Des();
CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
CleanupStack::PushL( mimeHeaders );
// attaInfo must be on top of stack because the ownership will be transferred
// to attacment manager.
CMsvAttachment* attaInfo = CMsvAttachment::NewL( CMsvAttachment::EMsvFile );
CleanupStack::PushL( attaInfo );
TPtrC8 contentType;
contentType.Set( KMmsTextPlain );
TInt position = contentType.Find( KMmsSlash8 );
mimeHeaders->SetContentTypeL( contentType.Left( position ) );
mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) );
attaInfo->SetMimeTypeL( contentType );
filename->Copy( TPtrC() );
aFile.Name( *filename ); // if this returns error, filename should be empty - no suggestion.
attaInfo->SetAttachmentNameL( *filename );
mimeHeaders->SetSuggestedFilenameL( *filename );
mimeHeaders->SetMimeCharset( KMmsUtf8 );
if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(
&aFs,
size * KMmsUnicodeToUtf2MaxIncrease + mimeHeaders->Size() + KMmsIndexEntryExtra,
aMessageDrive ) )
{
// we use standard error code here
User::Leave( KErrDiskFull );
}
mimeHeaders->StoreL( *attaInfo ); // Mime headers are streamed into atta info
MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();
RFile attaFile;
attaManSync.CreateAttachmentL( *filename, attaFile, attaInfo );
CleanupStack::Pop( attaInfo ); // attaInfo ownership was transferred.
aAttachmentId = attaInfo->Id();
// Now our file handle is open for writing
error = KErrNone;
TMmsFileText textFile;
textFile.Set( aFile );
while ( error == KErrNone || error == KErrTooBig )
{
error = textFile.Read( textPtr );
TBool appendCRLF = ETrue;
if ( error == KErrTooBig )
{
appendCRLF = EFalse;
error = KErrNone;
}
if ( error != KErrEof )
{
// if conversion fails, something is really seriously wrong
error = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, textPtr );
}
if ( error == KErrNone )
{
error = attaFile.Write( buf8 );
if ( error == KErrNone )
{
fileSize += buf8.Length();
if ( appendCRLF )
{
error = attaFile.Write( KMmsCrLf8 );
fileSize += KMmsLengthOfCRlf; // add length of carriage return/line feed
}
}
}
}
if ( error == KErrEof )
{
// end of file has been reached successfully
error = KErrNone;
}
if ( error == KErrNone )
{
error = attaFile.Flush();
}
attaFile.Close();
if ( error != KErrNone )
{
// Something went wrong when we tried to write our data.
// We must delete the attachment as it does not contain the
// intended data.
RemoveAttachmentL( aAttachmentId, aStore );
aAttachmentId = 0;
}
else
{
// If data writing was successful, the amount of data written
// is now stored in fileSize.
// Attachment info structure must be updated
MMsvAttachmentManager& attaMan = aStore.AttachmentManagerL();
attaInfo = attaMan.GetAttachmentInfoL( aAttachmentId );
CleanupStack::PushL( attaInfo );
attaInfo->SetSize( fileSize );
attaManSync.ModifyAttachmentInfoL( attaInfo );
// attachment manager now owns the attachment info
CleanupStack::Pop( attaInfo ); // attaInfo
}
CleanupStack::PopAndDestroy( mimeHeaders );
CleanupStack::PopAndDestroy( buffer );
CleanupStack::PopAndDestroy( textBuffer );
CleanupStack::PopAndDestroy( filename );
User::LeaveIfError( error );
}
// ---------------------------------------------------------
// CMmsAttachmentHandler::CreateTextAttachmentL
// ---------------------------------------------------------
EXPORT_C void CMmsAttachmentHandler::CreateTextAttachmentL(
CMsvStore& aStore,
TMsvAttachmentId& aAttachmentId,
const TDesC& aText,
const TDesC& aFile,
RFs& aFs,
TDriveUnit aMessageDrive,
TBool aConvertParagraphSeparator /*= ETrue*/ )
{
HBufC* convertedText = NULL;
TPtrC text;
if ( aConvertParagraphSeparator )
{
convertedText = CMsgTextUtils::ConvertParagraphSeparatorsLC( aText );
text.Set( convertedText->Des() );
}
else
{
text.Set( aText );
}
const TInt KMmsMaxBytesPerCharacter = 4;
// coverity[incorrect_multiplication][buffer_alloc]
HBufC8* buffer = HBufC8::NewL( text.Length() * KMmsMaxBytesPerCharacter ); // paranoid.
CleanupStack::PushL( buffer );
TPtr8 buf8 = buffer->Des();
CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
CleanupStack::PushL( mimeHeaders );
// attaInfo must be on top of stack because the ownership will be transferred
// to attacment manager.
CMsvAttachment* attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL( attaInfo );
TPtrC8 contentType;
contentType.Set( KMmsTextPlain );
TInt position = contentType.Find( KMmsSlash8 );
mimeHeaders->SetContentTypeL( contentType.Left( position ) );
mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) );
attaInfo->SetMimeTypeL( contentType );
attaInfo->SetAttachmentNameL( aFile );
mimeHeaders->SetMimeCharset( KMmsUtf8 );
mimeHeaders->SetSuggestedFilenameL( aFile );
// if conversion fails, something is really seriously wrong
TInt error = CnvUtfConverter::ConvertFromUnicodeToUtf8( buf8, text );
if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(
&aFs,
buf8.Length() + mimeHeaders->Size() + KMmsIndexEntryExtra,
aMessageDrive ) )
{
// we use standard error code here
User::Leave( KErrDiskFull );
}
else
{
User::LeaveIfError( error );
}
attaInfo->SetSize( buf8.Length() );
mimeHeaders->StoreL( *attaInfo ); // Mime headers are streamed into atta info
MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();
RFile attaFile;
attaManSync.CreateAttachmentL( aFile, attaFile, attaInfo );
CleanupStack::Pop( attaInfo ); // attaInfo ownership was transferred.
aAttachmentId = attaInfo->Id();
// Now our file handle is open for writing
if ( buf8.Length() > 0 )
{
attaFile.Write( buf8 );
error = attaFile.Flush();
}
attaFile.Close();
if ( error != KErrNone )
{
// Something went wrong when we tried to write our data.
// We must delete the attachment as it does not contain the
// intended data.
RemoveAttachmentL( aAttachmentId, aStore );
aAttachmentId = 0;
}
CleanupStack::PopAndDestroy( mimeHeaders );
CleanupStack::PopAndDestroy( buffer );
if ( convertedText )
{
CleanupStack::PopAndDestroy( convertedText );
convertedText = NULL;
}
User::LeaveIfError( error );
}
LOCAL_C void CreateNewPlaintextMessageL()
{
CTestActive* testActive = new(ELeave) CTestActive();
CleanupStack::PushL(testActive);
TMsvEmailTypeList msvEmailTypeList = 0;
TMsvPartList partList = (KMsvMessagePartBody | KMsvMessagePartAttachments);
CImEmailOperation* emailOperation = CImEmailOperation::CreateNewL(testActive->iStatus, *(testUtils->iMsvSession),KMsvGlobalOutBoxIndexEntryId, partList, msvEmailTypeList, KUidMsgTypeSMTP);
CleanupStack::PushL(emailOperation);
TestMsvOperationTimer* testMsvOperationTimer = TestMsvOperationTimer::NewLC(test.Console(), emailOperation, test);
testActive->StartL();
testMsvOperationTimer->IssueRequest();
CActiveScheduler::Start();
//check progress
TMsvId temp;
TPckgC<TMsvId> paramPack(temp);
const TDesC8& progBuf = emailOperation->ProgressL();
paramPack.Set(progBuf);
TMsvId newMessageId;
newMessageId = paramPack();
test(newMessageId != NULL);
CImEmailMessage* imEmailMessage = CImEmailMessage::NewLC(*(testUtils->iMsvEntry));
// Make sure you are set on the Message Id
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo);
attachmentInfo->SetAttachmentNameL(KAttachmentFileName1());
CleanupStack::Pop(attachmentInfo); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment1, attachmentInfo, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo1 = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo1);
attachmentInfo1->SetAttachmentNameL(KAttachmentFileName2());
CleanupStack::Pop(attachmentInfo1); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment2, attachmentInfo1, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo2 = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo2);
attachmentInfo2->SetAttachmentNameL(KAttachmentFileName3());
CleanupStack::Pop(attachmentInfo2); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment3, attachmentInfo2, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
const TDesC8& progBuf2 = imEmailMessage->ProgressL();
paramPack.Set(progBuf2);
TMsvId attachmentId = paramPack();
testUtils->WriteComment(_L("\t Created New plaintext message"));
testUtils->iMsvEntry->SetEntryL(attachmentId);
imEmailMessage->GetAttachmentsListL(testActive->iStatus, newMessageId, CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
const CMsvEntrySelection& selection = imEmailMessage->Selection();
testUtils->Printf(KTotalNoOfAttachment , selection.Count());
imEmailMessage->GetBodyTextEntryIdL(testActive->iStatus,newMessageId,CImEmailMessage::EThisMessageOnly);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
const CMsvEntrySelection& selection1 = imEmailMessage->Selection();
TInt count = imEmailMessage->Selection().Count();
if( count > 0)
{
// Get the Id of the body text
// The body text part Id is present at index 0. Not checking for other
// Ids, as currently only Plain text part is verified.
TMsvId iBodyTextId = imEmailMessage->Selection().At(0);
testUtils->Printf(KBodytextId, iBodyTextId);
}
CleanupStack::PopAndDestroy(); // imEmailMessage
testUtils->iMsvEntry->SetEntryL(attachmentId);
CMsvStore* store1 = testUtils->iMsvEntry->EditStoreL();
CleanupStack::PushL(store1);
CImMimeHeader *Head1 = CImMimeHeader::NewLC();
Head1->RestoreL(*store1);
const TPtrC8 contentSubType = Head1->ContentSubType();
store1->CommitL();
if(contentSubType.Size() == 0 )
{
testUtils->Printf(_L("ContentSubType Has NO SUB CONTENT****") );
test(contentSubType.Size() != 0);
}
else
{
testUtils->Printf(_L("ContentSubType Has ****SUB CONTENT****"));
}
CleanupStack::PopAndDestroy(2, store1);//store1,Head1,Buffer
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvStore* store = testUtils->iMsvEntry->EditStoreL();
CleanupStack::PushL(store);
CImHeader* header = CImHeader::NewLC();
header->RestoreL(*store);
TInt serverLength = testUtils->MachineName().Length();
HBufC* serverad = HBufC::NewL(serverLength + 7 ); // 7 is the length of KServerAddress
CleanupStack::PushL(serverad);
serverad->Des().Copy(testUtils->MachineName());
serverad->Des().Append(KServer);
HBufC* emailaddress = HBufC::NewL(serverLength + 8 + serverad->Des().Length() + 1 );
CleanupStack::PushL(emailaddress);
emailaddress->Des().Copy(testUtils->MachineName());
emailaddress->Des().Append(KAt);
emailaddress->Des().Append(*serverad);
header->ToRecipients().AppendL(*emailaddress);
header->SetSubjectL(_L("Test sending message using CMsvEntry::CopyL!!"));
header->StoreL(*store);
store->CommitL();
CleanupStack::PopAndDestroy(emailaddress);
CleanupStack::PopAndDestroy(serverad);
CleanupStack::PopAndDestroy(5,testActive); // header,store,testMsvOperationTimer,emailOperation,testActive
}
