// ----------------------------------------------------------------------------
// 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 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));
}
void CMtfTestActionAddEntryAttachment::RunTestL()
{
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TMsvId attachmentMessageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2));
CMsvEntry* entry = paramSession->GetEntryL(messageEntry);
CleanupStack::PushL(entry);
CMsvStore* store = entry->EditStoreL();
CleanupStack::PushL(store);
CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL();
CleanupStack::PushL(waiter);
CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvMessageEntry);
CleanupStack::PushL(attachment);
TMsvEntry attachmentEntry;
TMsvId attachmentServiceEntry;
User::LeaveIfError(paramSession->GetEntry(attachmentMessageEntry, attachmentServiceEntry, attachmentEntry));
attachment->SetSize(attachmentEntry.iSize);
MMsvAttachmentManager& manager = store->AttachmentManagerL();
manager.AddEntryAsAttachmentL(attachmentMessageEntry, attachment, waiter->iStatus);
CleanupStack::Pop(attachment); // ownership passed to manager
waiter->StartAndWait();
User::LeaveIfError(waiter->Result());
CleanupStack::PopAndDestroy(waiter);
TMsvAttachmentId attachmentId = attachment->Id();
store->CommitL();
CleanupStack::PopAndDestroy(2, entry); // store, entry
StoreParameterL<TMsvAttachmentId>(TestCase(),attachmentId,ActionParameters().Parameter(3));
}
//
// 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 );
}