void CMtfTestActionAddFileAttachmentByHandle::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));
iEntry = paramSession->GetEntryL(messageEntry);
iStore = iEntry->EditStoreL();
iAttachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
iAttachment->SetMimeTypeL(*paramMimeType);
RFile fileHandle = OpenFileL(paramSession->FileSession(), *paramFilePath);
CleanupClosePushL(fileHandle);
TFileName fileName;
User::LeaveIfError(fileHandle.Name(fileName));
iAttachment->SetAttachmentNameL(fileName);
TInt fileSize = 0;
User::LeaveIfError(fileHandle.Size(fileSize));
iAttachment->SetSize(fileSize);
MMsvAttachmentManager& manager = iStore->AttachmentManagerL();
CActiveScheduler::Add(this);
SetActive();
manager.AddAttachmentL(fileHandle, iAttachment, iStatus);
iAttachmentId = iAttachment->Id();
iAttachment = NULL; // ownership passed to manager
CleanupStack::Pop(&fileHandle);
}
TBool CRefTestAgentManager::IsRecognizedL(RFile& aFile) const
{
TBool result = EFalse;
// Get the name of the file
TFileName fileName;
aFile.Name(fileName);
// Check that the file has content only, otherwise it should
// be put through the supplier API before it can be used
TPtrC extension(fileName.Right(KRtaExtensionContent().Length()));
if(extension.CompareF(KRtaExtensionContent) == 0)
{
result = ETrue;
}
return result;
}
GLDEF_C TInt E32Main()
{
if(User::CreatorSecureId() != KTaskSchedulerSid)
{
// Not launched by Task Scheduler - exit
return KErrPermissionDenied;
}
TBuf<0x100> fileName;
RFile taskFile;
// Adopt the task file using the RFs handle into environment slot
// 1 and the RFile handle into slot 2
TInt err = taskFile.AdoptFromCreator(1,2);
if(KErrNone !=err)
{
return err;
}
taskFile.Name(fileName);
return Execute(fileName, taskFile);
}
EXPORT_C void CSmtpClientMtm::AddAttachmentL(RFile& aFile, 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::EMsvFile);
CleanupStack::PushL(attachmentInfo);
attachmentInfo->SetMimeTypeL(aMimeType);
TFileName fileName;
aFile.Name(fileName);
attachmentInfo->SetAttachmentNameL(fileName);
if( aCharset!=0 )
{
CMsvMimeHeaders* headers = CMsvMimeHeaders::NewLC();
headers->SetMimeCharset(aCharset);
headers->StoreL(*attachmentInfo);
CleanupStack::PopAndDestroy(headers);
}
iEmailMessage->AttachmentManager().AddAttachmentL(aFile, attachmentInfo, iAttachmentWaiter->iStatus);
CleanupStack::Pop(attachmentInfo);// ownership passed to attachment manager
iAttachmentWaiter->StartWaitingL(aStatus, iEmailMessage, EFalse);
}
// ---------------------------------------------------------------------------
// CRoHandlerDMgrWrapper::DoDownloadRoapTriggerL
// ---------------------------------------------------------------------------
//
void CRoHandlerDMgrWrapper::DoDownloadRoapTriggerL( TMeterState aNextState )
{
RFile roapTrigger;
DRM::CFileNameContainer* triggerFileName(NULL);
DRMDEBUGMETHOD( RoHdlrDMgrWrDebugLiterals::KMethDoDownloadAndHandleRoapTriggerL() );
// If no Trigger URL then nothing to download. So finish transaction
if ( !iTriggerUrl || iTriggerUrl->Length() <= 0 )
{
Continue( EComplete, KErrNone );
return;
}
triggerFileName=DRM::CFileNameContainer::NewLC();
#ifndef RD_MULTIPLE_DRIVE
User::LeaveIfError( roapTrigger.Temp(
iFs, KHelperTriggerFilePath, triggerFileName->iBuffer, EFileWrite ) );
#else //RD_MULTIPLE_DRIVE
_LIT( KDrive, "%c:\\" );
TInt driveNumber( -1 );
TChar driveLetter;
DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRam, driveNumber );
iFs.DriveToChar( driveNumber, driveLetter );
DRM::CFileNameContainer*
helperTriggerFilePath( DRM::CFileNameContainer::NewLC() );
helperTriggerFilePath->iBuffer.Format( KDrive, ( TUint )driveLetter );
User::LeaveIfError( roapTrigger.Temp( iFs, helperTriggerFilePath->iBuffer,
triggerFileName->iBuffer, EFileWrite ) );
CleanupStack::PopAndDestroy( helperTriggerFilePath );
helperTriggerFilePath=NULL;
#endif
UpdateBufferL< HBufC, TFileName >( iFileName, triggerFileName->iBuffer );
CleanupStack::PopAndDestroy( triggerFileName );
triggerFileName=NULL;
try
{
// create and start download
QString downloadUrl((QChar*)iTriggerUrl->Des().Ptr(),iTriggerUrl->Length());
iDownload = iDlMgr->createDownload( downloadUrl );
iRoHandlerDMgrEventHandler = q_check_ptr(new QRoHandlerDMgrEventHandler(*this, *iDownload));
}
catch(const std::exception& exception)
{
qt_symbian_exception2LeaveL(exception);
}
CleanupClosePushL( roapTrigger );
DRMDEBUG2(
RoHdlrDMgrWrDebugLiterals::KFormatDoDlHdlRoapTrigL(),
&RoHdlrDMgrWrDebugLiterals::KStrDlCreated() );
iDownloadSuccess = EFalse;
iConnectionError = EFalse;
SetDefaultAccessPointL();
try
{
RBuf fileName;
User::LeaveIfError(fileName.Create(KMaxFileName));
CleanupClosePushL(fileName);
roapTrigger.Name(fileName);
const QVariant& roapTriggerValue( QString((QChar*) fileName.Ptr(), fileName.Length()) );
CleanupStack::PopAndDestroy(&fileName);
iDownload->setAttribute(FileName,roapTriggerValue);
const QVariant& val(ETrue);
iDownload->setAttribute(ContentType, val);
iDownload->start();
}
catch(const std::exception& exception)
{
qt_symbian_exception2LeaveL(exception);
}
// wait until download is finished
iState = aNextState;
TRequestStatus* status( &iStatus );
*status = KRequestPending;
SetActive();
CleanupStack::PopAndDestroy( &roapTrigger );
}
// ---------------------------------------------------------
// 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::CreateAttachmentL
// ---------------------------------------------------------
//
EXPORT_C void CMmsAttachmentHandler::CreateAttachmentL(
CMsvStore& aStore,
RFile& aFile,
RFs& aFs,
TDriveUnit aMessageDrive,
TDesC8& aMimeType,
CMsvMimeHeaders& aMimeHeaders,
CMsvAttachment* aAttachmentInfo,
TMsvAttachmentId& aAttaId)
{
// The ownership of aAttachmentInfo will be transferred to attachment manager
// We must keep it safe until that time
CleanupStack::PushL( aAttachmentInfo );
// Check that sufficient disk space available
// for attachment binary file and index entry
TInt error = KErrNone;
TInt fileSize = 0;
error = aFile.Size( fileSize );
User::LeaveIfError( error );
aAttachmentInfo->SetSize( fileSize );
if ( aMimeHeaders.SuggestedFilename().Length() == 0 )
{
TFileName name;
error = aFile.Name( name );
if ( error == KErrNone )
{
aMimeHeaders.SetSuggestedFilenameL( name );
}
}
if ( aMimeHeaders.SuggestedFilename().Length() > 0 )
{
aAttachmentInfo->SetAttachmentNameL( aMimeHeaders.SuggestedFilename() );
}
if ( aMimeType.Length() > 0 )
{
aAttachmentInfo->SetMimeTypeL( aMimeType );
}
// Check that sufficient disk space available
// for attachment binary file and index entry
// This does not include mime headers.
// The mime headers are covered by KMmsIndexEntryExtra,
// however the value may be too small, has to be checked.
if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(
&aFs,
fileSize + KMmsIndexEntryExtra,
aMessageDrive ) )
{
// we use standard error code here
User::Leave( KErrDiskFull );
}
if ( ( aMimeHeaders.ContentType().Length() == 0 ||
aMimeHeaders.ContentSubType().Length() == 0 ) && aMimeType.Length() > 0 )
{
TInt position = aMimeType.Find( KMmsSlash8 );
if ( position > 0 )
{
aMimeHeaders.SetContentTypeL( aMimeType.Left( position ) );
}
if ( position < aMimeType.Length() - 1 )
{
aMimeHeaders.SetContentSubTypeL( aMimeType.Mid( position + 1 ) );
}
}
MMsvAttachmentManagerSync& attaManSync = aStore.AttachmentManagerExtensionsL();
RFile attaFile;
// ownership of aAttachmentInfo is transferred to attachment manager.
attaManSync.CreateAttachmentL( aMimeHeaders.SuggestedFilename(),
attaFile, aAttachmentInfo );
aAttaId = aAttachmentInfo->Id();
CleanupStack::Pop( aAttachmentInfo ); // attachment manager now owns aAttachmentInfo
// If the previous call was successful, we can now write the data
// We need a buffer because we read from one file and write to another
CleanupClosePushL( attaFile );
if ( fileSize > 0 )
{
// Greedy, but we don't try to swallow large files all in one piece
// Small files may be handled in one piece
HBufC8* buffer = HBufC8::NewL( Min( fileSize, KMms10kilos ) ); // Try to get at least 10 k
CleanupStack::PushL( buffer );
TPtr8 ptr = buffer->Des();
ptr.SetLength( 1 ); // initialized to something larger that 0, size is adjusted later
while( ptr.Length() > 0 && error == KErrNone )
{
error = aFile.Read( ptr );
if ( ptr.Length() > 0 && error == KErrNone)
{
error = attaFile.Write( ptr );
}
}
if ( error == KErrNone )
{
error = attaFile.Flush();
}
CleanupStack::PopAndDestroy( buffer );
buffer = NULL;
}
// we must alway close
CleanupStack::PopAndDestroy( &attaFile ); // close attaFile
// Now actual datafile is ready.
// We still have the atta info, and we must store the mimeheaders
aMimeHeaders.StoreL( *aAttachmentInfo );
// Now all should be ready.
// Caller must commit store (maybe headers still need to be changed,
// or maybe several attachments are added before committing store)
User::LeaveIfError( error );
}