/*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Implements document for application.
*
*/
// INCLUDE FILES
#include "MailLog.h"
#include "MailUtils.h"
#include "MsgMailViewerDocument.h"
#include "MsgMailViewerAppUi.h"
#include <MsgMailViewer.rsg>
#include "MsgMailDRMHandler.h"
#include "CMailCRHandler.h"
#include "CMailForwardOperation.h"
#include "MsgMailViewerRemoveAttachment.h"
#include <CMailMessage.h>
#include <Muiumsginfo.hrh>
#include <MuiuMsgEditorLauncher.h> // for TEditorParameters
#include <miutmsg.h>
#include <mtmuibas.h>
#include <mmsvattachmentmanager.h>
#include <MsgAttachmentModel.h>
#include <MsgAttachmentInfo.h>
#include <DocumentHandler.h>
#include <MuiuOperationWait.h> // CMuiuOperationWait
#include <impicmds.h> // TIMAP4Cmds
#include <sendui.h>
#include <mtmuidef.hrh>
// LOCAL CONSTANTS
// Max param length for msg info.
const TInt KMessageSizeMaxLength(10);
// ================= MEMBER FUNCTIONS =======================
// Default constructor
CMsgMailViewerDocument::CMsgMailViewerDocument(CEikApplication& aApp)
: CMsgMailDocument(aApp), iCharSet(0)
{
}
// destructor
CMsgMailViewerDocument::~CMsgMailViewerDocument()
{
delete iViewedMessage;
delete iPrefs;
iPrefs = NULL; // Owned by a superclass
delete iDRMHandler;
delete iSendUi;
delete iMailCRHandler;
}
// Symbian OS default constructor can leave.
void CMsgMailViewerDocument::ConstructL()
{
CMsgEditorDocument::ConstructL();
iMailCRHandler = CMailCRHandler::NewL( this );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::DoInitDRMHandlerL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::DoInitDRMHandlerL()
{
if (!iDRMHandler)
{
LOG("CMsgMailViewerAppUi::DoInitDRMHandlerL initializing DRM");
iDRMHandler = MsgMailDRMHandler::NewL();
}
}
// ----------------------------------------------------------------------------
// Two-phased constructor.
// ----------------------------------------------------------------------------
//
CMsgMailViewerDocument* CMsgMailViewerDocument::NewL(
CEikApplication& aApp) // CMsgMailViewerApp reference
{
CMsgMailViewerDocument* self = new (ELeave) CMsgMailViewerDocument( aApp );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::CreateAppUiL()
// constructs CMsgMailViewerAppUi
// ----------------------------------------------------------------------------
//
CEikAppUi* CMsgMailViewerDocument::CreateAppUiL()
{
return new (ELeave) CMsgMailViewerAppUi;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::NotifyChanges()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::NotifyChanges(TMsgAttachmentCommand aCommand,
CMsgAttachmentInfo* /*aAttachmentInfo*/ )
{
switch (aCommand)
{
case EMsgAttachmentAdded:
// FALLTHROUGH
case EMsgAttachmentRemoved:
SetChanged(ETrue);
break;
default:
break;
}
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::GetAttachmentFileL()
// ----------------------------------------------------------------------------
//
RFile CMsgMailViewerDocument::GetAttachmentFileL( TMsvAttachmentId aId )
{
LOG1("CMsgMailViewerDocument::GetAttachmentFileL %08x", aId);
return MailMessage().GetFileHandleL( aId );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::EntryChangedL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::EntryChangedL()
{
delete iViewedMessage;
iViewedMessage = NULL;
iViewedMessage = CMailMessage::NewL(CurrentEntry());
iViewedMessage->SetNew( (LaunchFlags() & EMsgUnreadMessage) );
LOG2( "CMsgMailViewerDocument::EntryChangedL %08x is new:%d" ,
MailMessage().MessageEntry().Id(), iViewedMessage->IsNew() );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::AddAttachmentL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::AddAttachmentL(
CMsvAttachment& aAttachmentInfo,
TBool aCanBeRemoved )
{
// add attachment to model
CMsgAttachmentModel& attmodel = AttachmentModel();
TDataType dataType(aAttachmentInfo.MimeType());
if ( aAttachmentInfo.Type() != CMsvAttachment::EMsvMessageEntry )
{
RFile attachment = GetAttachmentFileL( aAttachmentInfo.Id() );
CleanupClosePushL(attachment);
dataType = ResolveMimeType( attachment );
if ( !dataType.Des().Length() && aAttachmentInfo.MimeType().Length() )
{
dataType = aAttachmentInfo.MimeType();
}
CMsgAttachmentInfo* info = attmodel.AddAttachmentL(
aAttachmentInfo.AttachmentName(),
aAttachmentInfo.Size(),
aAttachmentInfo.Id(),
aAttachmentInfo.Complete(),
dataType);
TMsvId serviceId;
TMsvEmailEntry attachmentEntry;
User::LeaveIfError(Session().GetEntry(
aAttachmentInfo.Id(), serviceId, attachmentEntry));
info->SetAttachedThisSession( aCanBeRemoved );
LOG1("CMsgMailViewerAppUi::AddAttachmentL attachment complete:%d",
attachmentEntry.Complete());
LOG1("CMsgMailViewerAppUi::AddAttachmentL attachment BodyComplete:%d",
attachmentEntry.BodyTextComplete());
DoInitDRMHandlerL();
iDRMHandler->SetDRMDataTypeL( *info, attachment );
CleanupStack::PopAndDestroy(); // attachment
}
else // EMsvMessageEntry
{
// completed flag is not set correctly to message entry info
CMsgAttachmentInfo* info = attmodel.AddAttachmentL(
aAttachmentInfo.AttachmentName(),
aAttachmentInfo.Size(),
aAttachmentInfo.Id(),
ETrue /*aAttachmentInfo.Complete()*/,
dataType);
info->SetAttachedThisSession( aCanBeRemoved );
}
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::CanSaveFileL()
// ----------------------------------------------------------------------------
//
TBool CMsgMailViewerDocument::CanSaveFileL( TDataType aDataType )
{
// remove save if system doesn't support saving
CDocumentHandler* doch = CDocumentHandler::NewLC(
CEikonEnv::Static()->Process() ); // CSI: 27 # Must be used because of
// iEikEnv is not accessible.
TBool canSave(EFalse);
TRAP_IGNORE( canSave = doch->CanSaveL( aDataType ) );
// if error hide save
CleanupStack::PopAndDestroy(); //doch
return canSave;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::DeleteMessageL()
// ----------------------------------------------------------------------------
//
TBool CMsgMailViewerDocument::DeleteMessageL()
{
CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection;
CleanupStack::PushL(sel);
TMsvId msgID = MailMessage().MessageEntry().Id();
sel->AppendL( msgID );
Mtm().SwitchCurrentEntryL( MailMessage().MessageEntry().Parent() );
CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
CMsvOperation* op = MtmUi().DeleteFromL( *sel, wait->iStatus );
CleanupStack::PushL(op);
//Check if delete is cancelled from IMUM menu
TBool cancel(op->iStatus.Int() == KErrCancel);
//When deleting is really started we proceed
//as it was done complitely (= close viewer).
//Reason for this is that we don't
//know if IMUM has deleted message completely
//or not.
wait->Start();
CleanupStack::PopAndDestroy(3); // CSI: 47 # op, wait, sel
return cancel;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::FetchAttachmentL()
// ----------------------------------------------------------------------------
//
CMsvOperation* CMsgMailViewerDocument::FetchAttachmentL(
CMsvEntrySelection& aSelection, TRequestStatus& aCompletionStatus )
{
TBuf8<1> param;
// Set context back to message if not allready set
SetEntryWithoutNotificationL( MailMessage().MessageEntry().Id() );
return MtmUi().InvokeAsyncFunctionL(
KImpiMTMFetchAttachments, aSelection, aCompletionStatus, param );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::FetchAttachmentL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::FetchAttachmentL( CMsvEntrySelection& aSelection )
{
CMsvSingleOpWatcher* watch=CMsvSingleOpWatcher::NewLC( *this );
CMsvOperation* op = FetchAttachmentL( aSelection, watch->iStatus );
// watch owns op before leave can occur
AddSingleOperationL(op, watch);
CleanupStack::Pop( watch ); // watch
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::FetchAttachmentL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::FetchAttachmentL( TMsvAttachmentId aAttachmentId )
{
CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;
CleanupStack::PushL(sel);
sel->AppendL( aAttachmentId );
FetchAttachmentL( *sel );
CleanupStack::PopAndDestroy( sel );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::RemoveAttachmentL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::RemoveAttachmentL(
TMsvAttachmentId aAttachmentId )
{
CMsvSingleOpWatcher* watch=CMsvSingleOpWatcher::NewLC( *this );
LOG1("CMsgMailViewerDocument::RemoveAttachmentL %08x",
aAttachmentId);
TMsvId msgID = MailMessage().MessageEntry().Id();
CMsvOperation* op = CMsgMailViewerRemoveAttachmentOp::NewLC(
Session(), watch->iStatus, aAttachmentId, msgID );
CleanupStack::Pop(); // op
// watch owns op before leave can occur
AddSingleOperationL(op, watch);
CleanupStack::Pop( watch ); // watch
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::IsOnLineL()
// ----------------------------------------------------------------------------
//
TBool CMsgMailViewerDocument::IsOnLineL() const
{
const TMsvId entryId(CurrentEntry().OwningService());
CMsvEntry *entry = CMsvEntry::NewL(Session(),
entryId, TMsvSelectionOrdering());
const TBool result(entry->Entry().Connected());
delete entry;
return result;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::RetrieveMessageL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::RetrieveMessageL()
{
CMsvEntrySelection* sel= new (ELeave) CMsvEntrySelection();
CleanupStack::PushL( sel );
TMsvId messageId = Entry().Id();
sel->AppendL( messageId );
SetEntryL(Entry().Parent());
TBuf8<1> blankParams;
CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
CMsvOperation* op=MtmUi().InvokeAsyncFunctionL(
KMtmUiFunctionFetchSelected,
*sel,
wait->iStatus,
blankParams);
CleanupStack::PushL(op);
wait->Start();
// Set content back to message itself
SetEntryL(messageId);
// ignore return value.
MtmUi().DisplayProgressSummary( op->FinalProgress() );
CleanupStack::PopAndDestroy(3); // CSI: 47 # op, wait, sel
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::SendUiL()
// ----------------------------------------------------------------------------
//
CSendUi& CMsgMailViewerDocument::SendUiL()
{
if ( !iSendUi )
iSendUi = CSendUi::NewL();
return *iSendUi;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::ShowMessageInfoL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::ShowMessageInfoL()
{
CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection;
CleanupStack::PushL(sel);
TMsvId id( Entry().Id() );
sel->AppendL(id);
TBuf8<KMessageSizeMaxLength> infoParams(KMessageInfoViewer);
CMsvSingleOpWatcher* watch=CMsvSingleOpWatcher::NewLC(*this);
CMsvOperation* op= MtmUi().InvokeAsyncFunctionL(
KMtmUiFunctionMessageInfo,
*sel,
watch->iStatus,
infoParams
);
// watch owns op before leave can occur
AddSingleOperationL(op, watch);
CleanupStack::Pop(); // watch
CleanupStack::PopAndDestroy(); // sel
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::OpenMessageEntryL()
// ----------------------------------------------------------------------------
//
TBool CMsgMailViewerDocument::OpenMessageEntryL(TMsvId aEntryId )
{
TMsvEntry entry;
TMsvId service;
User::LeaveIfError( Session().GetEntry(aEntryId, service, entry) );
if (entry.iType==KUidMsvMessageEntry)
{
// dealing with attached message
const TMsvId prevEntry = CurrentEntry().EntryId();
SetEntryL( aEntryId );
// create watcher
CMsvSingleOpWatcher* watch=CMsvSingleOpWatcher::NewLC(
*this );
// open attached message
CMsvOperation* op = MtmUi().ViewL(watch->iStatus);
// add to operation queue, watch owns op before leave can occur
AddSingleOperationL(op, watch);
CleanupStack::Pop(); // watch
// set context back to original entry
SetEntryL(prevEntry);
return ETrue;
}
return EFalse;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::MailMessage()
// ----------------------------------------------------------------------------
//
CMailMessage& CMsgMailViewerDocument::MailMessage()
{
__ASSERT_DEBUG( iViewedMessage, User::Invariant() );
return *iViewedMessage;
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::MoveRemoteEntryL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::MoveRemoteEntryL(
TMsvId aTo, TMsvId aService, TBool aDestinationIsRemote )
{
CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection();
CleanupStack::PushL(sel);
sel->AppendL( MailMessage().MessageEntry().Id() );
CMsvOperation* op=NULL;
CMuiuOperationWait* wait = CMuiuOperationWait::NewLC();
if ( aDestinationIsRemote )
{
Mtm().SwitchCurrentEntryL( aTo );
op=MtmUi().CopyToL( *sel, wait->iStatus);
}
else
{
Mtm().SwitchCurrentEntryL( aService );
op=MtmUi().CopyFromL( *sel, aTo, wait->iStatus);
}
CleanupStack::PushL(op);
wait->Start(); // wait for completion of asynch operation
LOG1("CMsgMailViewerDocument::MoveRemoteEntryL iStatus:%d",
wait->iStatus.Int() );
User::LeaveIfError( wait->iStatus.Int() );
CleanupStack::PopAndDestroy(3); // CSI: 47 # sel, op, wait
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::UpdateAttachmentModelFromMessageL()
// ----------------------------------------------------------------------------
//
void CMsgMailViewerDocument::UpdateAttachmentModelFromMessageL()
{
// Now message is fetched, we'll update datatype information
//MailMessage().LoadAttachmentsL( *this );
MMsvAttachmentManager& manager = MailMessage().AttachmentManager();
LOG1("CMsgMailViewerDocument::UpdateAttachmentModelFromMessageL count:%d",
manager.AttachmentCount() );
}
// ----------------------------------------------------------------------------
// CMsgMailViewerDocument::ForwardMailMessageL()
// ----------------------------------------------------------------------------
//
CMailOperation* CMsgMailViewerDocument::ForwardMailMessageL(
MMsvProgressReporter& aReporter,
TRequestStatus& aStatus,
TBool aSetSuspend )
{
return CMailForwardOperation::NewL(
aReporter, *this, aStatus, aSetSuspend );
}
// End of File