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); }
// --------------------------------------------------------- // // --------------------------------------------------------- void CMmsAttachmentHandler::RemoveAttachmentL( TMsvAttachmentId aAttaId, CMsvStore& aStore ) { MMsvAttachmentManager& attaMan = aStore.AttachmentManagerL(); MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL(); // can only remove synchronously if index is known. TInt count = attaMan.AttachmentCount(); TInt i = count - 1; TBool found = EFalse; while ( i >= 0 && !found ) { CMsvAttachment* attachmentInfo = attaMan.GetAttachmentInfoL( i ); CleanupStack::PushL( attachmentInfo ); if ( attachmentInfo->Id() == aAttaId ) { found = ETrue; } else { i--; } CleanupStack::PopAndDestroy( attachmentInfo ); attachmentInfo = NULL; } if ( i >= 0 && found ) { attaManSync.RemoveAttachmentL( i ); } }
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)); }
//--------------------------------------------------------------- // CNativeMmsUtility::getSmilFileL // @see header //--------------------------------------------------------------- const QString CNativeMmsUtility::getSmilFileL() { #ifdef _DEBUG_TRACES_ qDebug() << " Enter CNativeMmsUtility::getSmilFileL"; #endif TUint count = iattachmanager->AttachmentCount(); for (int i = 0; i < count; i++) { CMsvAttachment *attachment = iattachmanager->GetAttachmentInfoL(i); if (attachment->MimeType().CompareF(KMsgMimeSmil) == 0) { #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getSmilFileL"; #endif return XQConversions::s60DescToQString(attachment->FilePath()); } } #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getSmilFileL"; #endif return QString(); }
// ---------------------------------------------------------------------------- // 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(); }
//--------------------------------------------------------------- // CNativeMmsUtility::getBodyTextFromAttManL // @see header //--------------------------------------------------------------- void CNativeMmsUtility::getBodyTextFromAttManL(QString& returnbuf) { #ifdef _DEBUG_TRACES_ qDebug() << " Enter CNativeMmsUtility::getBodyTextFromAttManL"; #endif TUint count = iattachmanager->AttachmentCount(); for (int i = 0; i < count; i++) { CMsvAttachment *attachment = iattachmanager->GetAttachmentInfoL(i); TPtrC8 mimetype = attachment->MimeType(); if (!isAttachment(attachment) && mimetype.CompareF(KMsgMimeTextPlain) == 0) { QString filepath = XQConversions::s60DescToQString(attachment->FilePath()); readFileIntoBuffer(filepath, returnbuf); break; } } #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getBodyTextFromAttManL"; #endif return; }
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 }
TInt32 CSmtpClientMtm::GetAttachmentSizeL(CImEmailMessage& aMessage, TMsvId aMsvId) { // Calculate the total size of all attachments associated with this message TInt total=0; aMessage.GetAttachmentsListL(iWait->iStatus, aMsvId, CImEmailMessage::EAllAttachments,CImEmailMessage::EThisMessageOnly); iWait->Start(); // wait for the asynch operation to complete TInt numAttachments=aMessage.AttachmentManager().AttachmentCount(); for (TInt n=0 ; n<numAttachments ; ++n) { CMsvAttachment* attachment = aMessage.AttachmentManager().GetAttachmentInfoL(n); total+=attachment->Size(); delete attachment; } return total; }
void CMtfTestActionRemoveAllAttachments::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionRemoveAllAttachments); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TInt attachIdFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2), 0); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->EditStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); TInt attachmentCount = manager.AttachmentCount(); for ( ; attachmentCount > 0 ; attachmentCount-- ) { CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); if( attachIdFlag == 1 ) { CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(0); CleanupStack::PushL(attachInfo); manager.RemoveAttachmentL(attachInfo->Id(), waiter->iStatus); CleanupStack::PopAndDestroy(attachInfo); } else { manager.RemoveAttachmentL(0, waiter->iStatus); } waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); } store->CommitL(); CleanupStack::PopAndDestroy(2, entry); // store, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionRemoveAllAttachments); TestCase().ActionCompletedL(*this); }
//--------------------------------------------------------------- // CNativeMmsUtility::getAttachmentListFromAttManL // @see header //--------------------------------------------------------------- void CNativeMmsUtility::getAttachmentListFromAttManL( ConvergedMessageAttachmentList& attachmentlist) { #ifdef _DEBUG_TRACES_ qDebug() << " Enter CNativeMmsUtility::getAttachmentListFromAttManL"; #endif TUint count = iattachmanager->AttachmentCount(); for (int i = 0; i < count; i++) { CMsvAttachment *attachment = iattachmanager->GetAttachmentInfoL(i); TPtrC8 mimetype = attachment->MimeType(); QString filepath = XQConversions::s60DescToQString(attachment->FilePath()); // converting directory separators from native to // universal (QT) format filepath.replace(KBackwardSlash, KForwardSlash); quint16 attachmenttype; if (isAttachment(attachment)) attachmenttype = ConvergedMessageAttachment::EAttachment; else attachmenttype = ConvergedMessageAttachment::EUnknown; //smil files aren't of either type if (mimetype.CompareF(KMsgMimeSmil) == 0) { ConvergedMessageAttachment * targetatt = new ConvergedMessageAttachment(filepath, ConvergedMessageAttachment::ESmil); attachmentlist << targetatt; } else { ConvergedMessageAttachment* targetatt = new ConvergedMessageAttachment(filepath, attachmenttype); attachmentlist << targetatt; } } #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getAttachmentListFromAttManL"; #endif }
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); }
void CMtfTestActionSmtpRemoveEntryAttachmentById::RunTestL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry); CleanupStack::PushL(emailMsg); MMsvAttachmentManager& manager = emailMsg->AttachmentManager(); CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(attachId); CleanupStack::PushL(attachInfo); // First ensure that the attachment is a file attachment if( attachInfo->Type() != CMsvAttachment::EMsvMessageEntry ) { User::Leave(KErrGeneral); } // Get the linked file TMsvId msgId = attachInfo->EntryAttachmentId(); CleanupStack::PopAndDestroy(attachInfo); // Remove the attachment CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); manager.RemoveAttachmentL(attachId, waiter->iStatus); waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); CleanupStack::PopAndDestroy(2, entry); // email msg, entry // Ensure that the message entry still exists CMsvEntry* checkEntry = paramSession->GetEntryL(msgId); delete checkEntry; checkEntry = NULL; }
/** Imports the Obex header list from the attachment. The header list is retrieved and stored in this object. Any existing header data is over-written with the headers from the attachment. If the headers have not been set, this obex list will still be over written and result in zero headers. @param aAttachment The attachment to retieve the header list from. @leave System-wide error codes. */ EXPORT_C void CObexHeaderList::ImportFromAttachmentL(CMsvAttachment& aAttachment) { TPtrC8 headerData; if( aAttachment.GetDesC8Attribute(KUidObexHeaders, headerData) == KErrNone ) { // header data exists, attempt to import it RDesReadStream readStream(headerData); readStream.PushL(); readStream >> *this; CleanupStack::PopAndDestroy(&readStream); }
void CMtfTestActionRemoveFileAttachmentWithDestroy::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionRemoveFileAttachmentWithDestroy); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->EditStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(attachId); CleanupStack::PushL(attachInfo); // First ensure that the attachment is a file attachment if( attachInfo->Type() != CMsvAttachment::EMsvFile ) { User::Leave(KErrGeneral); } CleanupStack::PopAndDestroy(attachInfo); CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); manager.RemoveAttachmentL(attachId, waiter->iStatus); waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); // destroy the store without commit CleanupStack::PopAndDestroy(2, entry); // store, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionRemoveFileAttachmentWithDestroy); TestCase().ActionCompletedL(*this); }
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)); }
/** Exports the Obex header list to the attachment. The header list is then stored with the attachment. @param aAttachment The attachment to store the header list for. @leave System-wide error codes. */ EXPORT_C void CObexHeaderList::ExportToAttachmentL(CMsvAttachment& aAttachment) const { // create a buffer stream to hold the header data CBufFlat* obexHdrBuf = CBufFlat::NewL(KObexHeaderListSegmentSize); CleanupStack::PushL(obexHdrBuf); // externalise the header list to the buffer RBufWriteStream writeStream(*obexHdrBuf); writeStream.PushL(); writeStream << *this; writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); // set the headers in the attachment aAttachment.SetDesC8AttributeL(KUidObexHeaders, obexHdrBuf->Ptr(0)); CleanupStack::PopAndDestroy(obexHdrBuf); }
/** CheckAttachmentsL() Compares attachments for the email messages aRecvEntry and aSentEntry using expected results in aMailInfo @param aRecvEntry An identifier for the recieved email @param aMailInfo Expected state of recieved email attachments @param aSentEntry An identifier for the original email @return ETrue if attachments match otherwise EFalse */ TBool CT_MsgComparePopEmailMsgs::CheckAttachmentsL(TMsvEntry& aRecvEntry, CExpPop3MailInfo& aMailInfo, TMsvEntry& aSentEntry) { TBool ret = ETrue; CAttachmentItem* recvManager = CAttachmentItem::NewLC(*iSharedDataPOP.iSession, aRecvEntry); CAttachmentItem* sentManager = CAttachmentItem::NewLC(*iSharedDataPOP.iSession, aSentEntry); TInt recvCount = recvManager->MMsvAttachmentManager().AttachmentCount(); TInt sentCount = sentManager->MMsvAttachmentManager().AttachmentCount(); TFileName recvFileName; TFileName sentFileName; if(recvCount == aMailInfo.GetNumAttachments()) { for(TInt i=0;i<recvCount;i++) { for(TInt j=0;j<sentCount;j++) { CMsvAttachment* recvAttInfo = recvManager->MMsvAttachmentManager().GetAttachmentInfoL(i); CleanupStack::PushL(recvAttInfo); CMsvAttachment* sentAttInfo = sentManager->MMsvAttachmentManager().GetAttachmentInfoL(j); CleanupStack::PushL(sentAttInfo); if(recvAttInfo->AttachmentName().Compare(sentAttInfo->AttachmentName()) == 0) { recvFileName = recvAttInfo->FilePath(); sentFileName = sentAttInfo->FilePath(); ret = CompareFilesL(recvFileName, sentFileName); } CleanupStack::PopAndDestroy(2, recvAttInfo); } } } else { INFO_PRINTF3(_L("Warning - Expected attachments mismatch recieved (%d) expected (%d)"), recvCount, aMailInfo.GetNumAttachments()); ret = EFalse; } CleanupStack::PopAndDestroy(2, recvManager); // recvManager,sentManager return ret; }
void CMtfTestActionVerifyAttachmentInfo::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionVerifyAttachmentInfo); CMsvAttachment* attachmentInfo = ObtainParameterReferenceL<CMsvAttachment>(TestCase(),ActionParameters().Parameter(0)); HBufC* paramFileName = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(1)); TInt paramFileSize = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2)); HBufC* paramMimeType = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(3)); TestCase().INFO_PRINTF1(_L("VerifyAttachmentInfo.....")); TestCase().INFO_PRINTF2(_L("Attachment Name - %S"), &attachmentInfo->AttachmentName()); TestCase().INFO_PRINTF2(_L("Size - %d"), attachmentInfo->Size()); TBuf<KMimeTypeLength> mimeType; mimeType.Copy(attachmentInfo->MimeType()); TestCase().INFO_PRINTF2(_L("MimeType - %S"), &mimeType); TestCase().INFO_PRINTF1(_L("With..")); TestCase().INFO_PRINTF2(_L("Attachment Name - %S"), paramFileName); TestCase().INFO_PRINTF2(_L("Size - %d"), paramFileSize); TestCase().INFO_PRINTF2(_L("MimeType - %S"), paramMimeType); if ( (paramFileName->Compare(attachmentInfo->AttachmentName()) == 0) && (paramMimeType->Compare(mimeType) == 0) && (paramFileSize == attachmentInfo->Size()) ) { } else { User::Leave(KErrGeneral); } TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionVerifyAttachmentInfo); TestCase().ActionCompletedL(*this); }
// // 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 } }
/* ----------------------------------------------------------------------------- RFile GetAttachmentFileL(TMsvAttachmentId aId) ---------------------------------------------------------------------------- */ void CMailBoxContainer::CopyFileL(const TDesC& aFolderName) { TFileName fileName,FullFilName; if(iSession && iSelectionBox && iListArray) { TInt CurrItmIndex = iSelCopyItemIndex; iSelCopyItemIndex = -1; if(CurrItmIndex < 0 || CurrItmIndex >= iIDArray->Count()) { 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) { fileName.Copy(attachment->AttachmentName()); delete attachment; attachment = NULL; TBool OkToSave(EFalse),SkipMe(EFalse); do { FullFilName.Zero(); StringLoader::Load(FullFilName,R_SH_STR_FILENAME); CAknTextQueryDialog* Dialog = CAknTextQueryDialog::NewL(fileName,CAknQueryDialog::ENoTone); Dialog->PrepareLC(R_ASK_NAME_DIALOG); Dialog->SetPromptL(FullFilName); if(Dialog->RunLD()) { FullFilName.Copy(aFolderName); FullFilName.Append(fileName); if(BaflUtils::FileExists(CEikonEnv::Static()->FsSession(),FullFilName)) { HBufC* TmpText = StringLoader::LoadLC(R_SH_STR_FILOVERRT); CAknQueryDialog* dlg = CAknQueryDialog::NewL(); if(dlg->ExecuteLD(R_QUERY,*TmpText)) { TInt Err = CEikonEnv::Static()->FsSession().Delete(FullFilName); if(Err == KErrNone) { OkToSave = ETrue; } else { iUtils.GetFileUtils().ShowFileErrorNoteL(FullFilName,Err); } } CleanupStack::PopAndDestroy(TmpText); } else { OkToSave = ETrue; } } else { SkipMe = ETrue; } }while(!SkipMe && !OkToSave); if(OkToSave) { delete iRFileCopier; iRFileCopier = NULL; iRFileCopier = CRFileCopier::NewL(*this,CEikonEnv::Static()->FsSession(),ETrue); RFile SourceFil(attMngr.GetAttachmentFileL(iIDArray->At(CurrItmIndex).iAtt)); iRFileCopier->StartCopyL(SourceFil,FullFilName); SourceFil.Close(); } } CleanupStack::PopAndDestroy(store); } CleanupStack::PopAndDestroy(2); } CleanupStack::PopAndDestroy(2); } }
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 }
void CheckNewAttachmentL(const TDesC& aFileName, TInt aFileSize, const TDesC8& aMimeType, TUint aCharset, TBool aLinkedAttachment) { // Check that file exists in the store and it matches our control file. 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]); CMsvStore* store = cEntry->ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& attachmentMgr = store->AttachmentManagerL(); TInt count = attachmentMgr.AttachmentCount(); test(count > 0); TBool found = EFalse; while( count-- > 0 && !found ) { CMsvAttachment* attachmentInfo = attachmentMgr.GetAttachmentInfoL(count); CleanupStack::PushL(attachmentInfo); // Check the attachment info is what we expect. TParse parser1; TParse parser2; parser1.Set(attachmentInfo->FilePath(), NULL, NULL); parser2.Set(aFileName, NULL, NULL); found = ETrue; if (aLinkedAttachment) { found = found && (attachmentInfo->Type() == CMsvAttachment::EMsvLinkedFile); // Check it's a linked file. found = found && (parser1.DriveAndPath() == parser2.DriveAndPath()); } else { found = found && (attachmentInfo->Type() == CMsvAttachment::EMsvFile); // Check it's a file. found = found && (parser1.DriveAndPath() != parser2.DriveAndPath()); } found = found && (attachmentInfo->MimeType().Match(aMimeType) == 0); // Check mime type matches. found = found && (parser1.NameAndExt() == parser2.NameAndExt()); // This necessarily correct? found = found && (attachmentInfo->Size() == aFileSize); // Check size matches. // check charset matches CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewLC(); mimeHeaders->RestoreL(*attachmentInfo); found = found && (mimeHeaders->MimeCharset() == aCharset); CleanupStack::PopAndDestroy(2, attachmentInfo); // mimeHeaders, attachmentInfo } test(found); CleanupStack::PopAndDestroy(5, ob1); // store, selection, cEntry, sesion, ob1 }
// --------------------------------------------------------- // 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 ); }
// --------------------------------------------------------- // 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 ); }
//--------------------------------------------------------------- // CNativeMmsUtility::getByUrlL // @see header //--------------------------------------------------------------- const QString CNativeMmsUtility::getByUrlL(const TDesC& url) { #ifdef _DEBUG_TRACES_ qDebug() << " Enter CNativeMmsUtility::getByUrlL"; #endif CMsvAttachment* targetattachment = NULL; TBool found = EFalse; //newlc puts it on cleanupstack HBufC8* url8bit = HBufC8::NewLC(url.Length()); CUri16* decodedUri = NULL; TUriParser8 parser; //get the uri in display format if (url.MatchF(KContentIdString) == 0) { //Remove "cid:" from the beginning url8bit->Des().Copy(url.Right(url.Length() - KContentIdString().Length() + 1)); parser.Parse(*url8bit); } else { url8bit->Des().Copy(url); parser.Parse(*url8bit); } decodedUri = UriUtils::ConvertToDisplayFormL(parser); CleanupStack::PushL(decodedUri); //run through the attachements to check for a match TUint count = iattachmanager->AttachmentCount(); for (int i = 0; i < count && !found; i++) { CMsvAttachment *attachment = iattachmanager->GetAttachmentInfoL(i); CleanupStack::PushL(attachment); //restore mimeheaders from the attachment CMsvMimeHeaders* mimeheaders = CMsvMimeHeaders::NewL(); CleanupStack::PushL(mimeheaders); mimeheaders->RestoreL(*attachment); //check for a match with content-loc and then content-id if (resolvedByContentLocL(mimeheaders->ContentLocation(), *decodedUri) || resolvedByContentIdL(mimeheaders->ContentId(), *decodedUri)) { targetattachment = CMsvAttachment::NewL(*attachment); found = ETrue; } CleanupStack::PopAndDestroy(2, attachment); //mimeheaders, attachment } CleanupStack::PopAndDestroy(decodedUri); if (url8bit) CleanupStack::PopAndDestroy(url8bit); if (targetattachment) { #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getByUrlL"; #endif return XQConversions::s60DescToQString(targetattachment->FilePath()); } else { #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getByUrlL"; #endif return QString(); } }
//--------------------------------------------------------------- // CNativeMmsUtility::getRemainingAttachmentsFromAttManL // @see header //--------------------------------------------------------------- void CNativeMmsUtility::getRemainingAttachmentsFromAttManL( ConvergedMessageAttachmentList& attachmentlist) { #ifdef _DEBUG_TRACES_ qDebug() << " Enter CNativeMmsUtility::getRemainingAttachmentsFromAttManL"; #endif TUint count = iattachmanager->AttachmentCount(); for (int i = 0; i < count; i++) { CMsvAttachment *attachment = iattachmanager->GetAttachmentInfoL(i); TPtrC8 mimetype = attachment->MimeType(); QString filepath = XQConversions::s60DescToQString(attachment->FilePath()); // converting directory separators from native to // universal (QT) format filepath.replace(KBackwardSlash, KForwardSlash); //create convergedmessage attachment to match with inline objects ConvergedMessageAttachment compareatt(filepath, ConvergedMessageAttachment::EInline); //before adding to the list check if already present in the list TBool found = EFalse; TUint listcount = attachmentlist.count(); for (int j = 0; j < listcount && !found; j++) { if (compareatt == *attachmentlist.at(j)) { found = ETrue; } } //no match found in the list if (!found) { //smil files aren't of either type if (mimetype.CompareF(KMsgMimeSmil) == 0) { ConvergedMessageAttachment * targetatt = new ConvergedMessageAttachment(filepath, ConvergedMessageAttachment::ESmil); attachmentlist << targetatt; } else { ConvergedMessageAttachment * targetatt = new ConvergedMessageAttachment(filepath, ConvergedMessageAttachment::EAttachment); attachmentlist << targetatt; } } } #ifdef _DEBUG_TRACES_ qDebug() << " Exit CNativeMmsUtility::getRemainingAttachmentsFromAttManL"; #endif return; }