FCL/sf/app/commonemail: comparison emailservices/emailclientapi/src/emailmailbox.cpp

equal deleted inserted replaced

-:e1b6206813b4
+:f5907b1a1053
 /*
 * Copyright (c) 2009 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".
 *
 * Description: This file implements class CEmailMailbox.
 *
 */
 #include <e32cmn.h>
 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
 #include <viewclipartner.h>
 #include <vwsdefpartner.h>
 #else
 #include <viewcli.h>
 #include "cfsmailbox.h"
 #include "cfsmailfolder.h"
 #include "emailclientapi.hrh"
 #include "FreestyleEmailUiConstants.h"
-// -----------------------------------------------------------------------------
+// Constants
-//
-// -----------------------------------------------------------------------------
+_LIT( KNewLine, "\n" );
-CEmailMailbox* CEmailMailbox::NewL(
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+CEmailMailbox* CEmailMailbox::NewL(
 CPluginData& aPluginData,
 const TMailboxId& aMailboxId )
 {
 CEmailMailbox* self = new ( ELeave ) CEmailMailbox( aPluginData, aMailboxId );
 CleanupStack::PushL( self );
 CleanupStack::Pop();
 return self;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMailbox::CEmailMailbox(
 CPluginData& aPluginData,
 const TMailboxId& aMailboxId )
 : iPluginData( aPluginData ),
 iMailboxId( aMailboxId.iId )
 {
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::ConstructL()
 {
 iPlugin = iPluginData.ClaimInstanceL();
 iEventMapper = new ( ELeave ) TObserverEventMapper(
 iPlugin, iPluginData.Uid(), iMailboxId );
 iFsMailbox = iPlugin->GetMailBoxByUidL( FsMailboxId() );
 iSyncObserver = new (ELeave) CEmailMailbox::CEmailRequestObserver();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMailbox::~CEmailMailbox()
 {
 delete iFsMailbox;
 delete iEventMapper;
 iPluginData.ReleaseInstance();
 delete iSyncObserver;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TEmailTypeId CEmailMailbox::InterfaceId() const
 {
 return KEmailIFUidMailbox;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::Release()
 {
 delete this;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TMailboxId CEmailMailbox::MailboxId() const
 {
 return iMailboxId;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailAddress* CEmailMailbox::AddressL() const
 {
 if ( !iAddress )
 {
 iAddress = CEmailAddress::NewL(
 MEmailAddress::ESender, EAPIOwns );
 iAddress->SetDisplayNameL( iFsMailbox->GetName() );
 iAddress->SetAddressL( iFsMailbox->OwnMailAddress().GetEmailAddress() );
 }
 return iAddress;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TPtrC CEmailMailbox::MailboxName() const
 {
 return iFsMailbox->GetName();
 }
 // Constructs and returns type mailbox id of internal data type TFSMailMsgId
 // -----------------------------------------------------------------------------
 TFSMailMsgId CEmailMailbox::FsMailboxId() const
 {
 return FsMsgId( iPluginData, iMailboxId );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TInt CEmailMailbox::GetFoldersL( RFolderArray& aFolders ) const
 {
 TFSMailMsgId rootId = TFSMailMsgId();
 RPointerArray<CFSMailFolder> folders;
 CleanupResetAndDestroyPushL( folders );
 iPlugin->ListFoldersL( FsMailboxId(), rootId, folders );
 TInt res( folders.Count() );
 for ( TInt i = 0; i < res; i++ )
 {
 const CFSMailFolder* fsfolder = folders[i];
 const TEntryId id = fsfolder->GetFolderId().Id();
 const TFolderId folderId( id, iMailboxId );
 CEmailFolder* folder = CEmailFolder::NewLC( iPluginData, folderId, folders[i] );
 aFolders.AppendL( folder );
 CleanupStack::Pop();    // folder
 }
 CleanupStack::Pop();    // folders
 folders.Close(); // close but don't delete folders because they are
 // owned by CEmailFolder
 return res;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailFolder* CEmailMailbox::FolderL( const TFolderId& aFolderId ) const
 {
 CFSMailFolder* fsFolder = iPlugin->GetFolderByUidL(
 FsMsgId( iPluginData, iMailboxId ),
 FsMsgId( iPluginData, aFolderId ) );
 CleanupStack::PushL( fsFolder );
 CEmailFolder* folder = CEmailFolder::NewL( iPluginData,
 aFolderId, fsFolder);
 CleanupStack::Pop();    // folder
 return folder;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailFolder* CEmailMailbox::FolderByTypeL(
 const TFolderType aFolderType ) const
 {
 TFSMailMsgId fsFolderId;
 switch ( aFolderType )
 {
 case EInbox:
 fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSInbox );
 case EOutbox:
 fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSOutbox );
 case EDrafts:
 fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSDraftsFolder );
 case EDeleted:
 fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSDeleted );
 case ESent:
 fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSSentFolder );
 case EOther:
 default:
 User::Leave( KErrNotFound );
 break;
 }
 const TFolderId folderId( fsFolderId.Id(), iMailboxId );
 CFSMailFolder* fsFolder = iPlugin->GetFolderByUidL(
 FsMsgId( iPluginData, iMailboxId ),
 fsFolderId );
 CleanupStack::PushL( fsFolder );
 CEmailFolder* folder = CEmailFolder::NewL( iPluginData,
 folderId,
 fsFolder );
 CleanupStack::Pop();
 return folder;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessage* CEmailMailbox::MessageL( const TMessageId& aMessageId )
 {
 CFSMailMessage *fsMessage = iPlugin->GetMessageByUidL(
 FsMsgId( iPluginData, aMessageId.iFolderId.iMailboxId ),
 FsMsgId( iPluginData, aMessageId.iFolderId ),
 FsMsgId( iPluginData, aMessageId ),
 EFSMsgDataEnvelope);
 CleanupStack::PushL( fsMessage );
 CEmailMessage* message = CEmailMessage::NewL( iPluginData, fsMessage, EClientOwns );
 CleanupStack::Pop();  // fsMessage
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessage* CEmailMailbox::CreateDraftMessageL() const
 {
 CFSMailMessage* fsMessage = iFsMailbox->CreateMessageToSend();
-CleanupStack::PushL( fsMessage );
+User::LeaveIfNull( fsMessage );
+CleanupStack::PushL( fsMessage );
 MEmailMessage* message = CEmailMessage::NewL( iPluginData, fsMessage, EClientOwns );
 CleanupStack::Pop();  // fsMessage
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessage* CEmailMailbox::CreateReplyMessageL( const TMessageId& aMessageId, const TBool aReplyToAll ) const
 {
 CFSMailMessage* fsMessage = iFsMailbox->CreateReplyMessage( FsMsgId( iPluginData, aMessageId ), aReplyToAll );
-CleanupStack::PushL( fsMessage );
+User::LeaveIfNull( fsMessage );
+CleanupStack::PushL( fsMessage );
 MEmailMessage* message = CEmailMessage::NewL( iPluginData, fsMessage, EClientOwns );
 CleanupStack::Pop();  // fsMessage
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessage* CEmailMailbox::CreateForwardMessageL( const TMessageId& aMessageId ) const
 {
-CFSMailMessage* fsMessage = iFsMailbox->CreateForwardMessage( FsMsgId( iPluginData, aMessageId ) );
+CFSMailMessage* fsMessage = iFsMailbox->CreateForwardMessage(
-CleanupStack::PushL( fsMessage );
+FsMsgId( iPluginData, aMessageId ), KNewLine() );
+User::LeaveIfNull( fsMessage );
+CleanupStack::PushL( fsMessage );
 MEmailMessage* message = CEmailMessage::NewL( iPluginData, fsMessage, EClientOwns );
 CleanupStack::Pop();  // fsMessage
 return message;
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::SynchroniseL( MMailboxSyncObserver& aObserver )
 {
 iSyncObserver->SetObserverL( &aObserver );
 iRequestId = iFsMailbox->RefreshNowL( *iSyncObserver );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::CancelSynchronise()
 {
 iFsMailbox->CancelSearch();
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::RegisterObserverL( MMailboxContentObserver& aObserver )
 {
 iEventMapper->AddObserverL( aObserver );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 void CEmailMailbox::UnregisterObserver( MMailboxContentObserver& aObserver )
 {
 iEventMapper->RemoveObserver( aObserver );
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 MEmailMessageSearchAsync* CEmailMailbox::MessageSearchL()
 {
 MEmailMessageSearchAsync* searchAPI = CEmailMessageSearchAsync::NewL( iPluginData, iMailboxId );
 return searchAPI;
 }
 void CEmailMailbox::ShowInboxL()
 {
 TMailListActivationData mailListData;
 mailListData.iMailBoxId = FsMsgId(iPluginData, iMailboxId);
 TPckgBuf<TMailListActivationData> pkgOut( mailListData );
 CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
 viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailListId), KStartListWithFolderId, pkgOut);
 CleanupStack::PopAndDestroy();
 }
 void CEmailMailbox::EditNewMessageL()
 {
 TEditorLaunchParams editorLaunchData;
 editorLaunchData.iMailboxId = FsMsgId(iPluginData, iMailboxId);
 editorLaunchData.iActivatedExternally = ETrue;
 TPckgBuf<TEditorLaunchParams> pckgData( editorLaunchData );
 CVwsSessionWrapper* viewSrvSession = CVwsSessionWrapper::NewLC();
 TUid command = TUid::Uid(KEditorCmdCreateNew);
 viewSrvSession->ActivateView(TVwsViewId(KFSEmailUiUid, MailEditorId), command, pckgData);
 CleanupStack::PopAndDestroy( viewSrvSession );
 /*
 void CEmailMailbox::GetLatestMail()
 {
 CFSMailFolder* fsFolder = NULL;
 TFSMailMsgId fsFolderId = iPlugin->GetStandardFolderIdL( FsMailboxId(), EFSInbox );
 }
 */
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMailbox::TObserverEventMapper::TObserverEventMapper(
 CFSMailPlugin* aPlugin,
 TUid aPluginUid, const TMailboxId& aMailboxId )
 : iPlugin( aPlugin ),
 iFsMailboxId( aPluginUid.iUid, aMailboxId.iId )
 {
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 CEmailMailbox::TObserverEventMapper::~TObserverEventMapper()
 {
 iClientObservers.Close();
 }
 // -----------------------------------------------------------------------------
 // Maps protocol a plugin event to client event
 // -----------------------------------------------------------------------------
 void CEmailMailbox::TObserverEventMapper::EventL(
 TFSMailEvent aEvent,
 TFSMailMsgId aMailbox,
 TAny* aParam1,
 TAny* aParam2,
 TAny* aParam3 )
 {
 const TEventMapFunc KMailboxEventHandlers[] = {
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::IgnoreEventL,
 CEmailMailbox::TObserverEventMapper::NewMessageL,
 CEmailMailbox::TObserverEventMapper::MessageChangedL,
 CEmailMailbox::TObserverEventMapper::MessageDeletedL,
 CEmailMailbox::TObserverEventMapper::MessageMoved,
 CEmailMailbox::TObserverEventMapper::MessageCopiedL,
 CEmailMailbox::TObserverEventMapper::NewFolderL,
 CEmailMailbox::TObserverEventMapper::FolderChangeL,
 CEmailMailbox::TObserverEventMapper::FoldersDeletedL,
 CEmailMailbox::TObserverEventMapper::FoldersMovedL,
 CEmailMailbox::TObserverEventMapper::ExceptionL
 };
 // boundary check
 const TInt index( aEvent );
 if ( index < sizeof( KMailboxEventHandlers ) / sizeof( KMailboxEventHandlers[ index ] ) )
 {
 // call event handler function
 TEventMapFunc method = KMailboxEventHandlers[ index ];
 (this->*method)(id, aParam1,aParam2,aParam3 );
 }
 }
 void CEmailMailbox::TObserverEventMapper::IgnoreEventL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::NewMessageL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::MessageChangedL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::MessageDeletedL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::MessageMoved(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::MessageCopiedL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::NewFolderL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::FolderChangeL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::FoldersDeletedL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::FoldersMovedL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 void CEmailMailbox::TObserverEventMapper::ExceptionL(
 TMailboxId /*aMailbox*/, TAny* /*aParam1*/, TAny* /*aParam2*/, TAny* /*aParam3*/ )
 {
 }
 // -----------------------------------------------------------------------------
 //
 // -----------------------------------------------------------------------------
 TBool CEmailMailbox::TObserverEventMapper::Equals( const MMailboxContentObserver& a1, const MMailboxContentObserver& a2 )
 {
 return ( &a1 == &a2 );
 }
 CEmailMailbox::CEmailRequestObserver::CEmailRequestObserver() : iObserver( NULL )
 {
 }
 void CEmailMailbox::CEmailRequestObserver::RequestResponseL( TFSProgress aEvent, TInt /* aRequestId */ )
 {
 if (aEvent.iProgressStatus == TFSProgress::EFSStatus_RequestComplete)
 {
 iObserver->MailboxSynchronisedL(aEvent.iError);
 }
 }
 void CEmailMailbox::CEmailRequestObserver::SetObserverL( MMailboxSyncObserver* aObserver )
 {

branch	RCL_3
changeset 12	f5907b1a1053
parent 8	e1b6206813b4
child 13	0396474f30f5