1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *       Copy or move a selection of messages that may or may not be complete

    16 *

    17 */

    18 

    19 

    20 #include <eikenv.h>

    21 #include <eikrutil.h>

    22 

    23 #include "Imap4CopyMoveLocalOp.h"

    24 #include "Imap4FetchOp.h"

    25 #include "EmailMsgSizerOperation.h"

    26 #include "EmailUtils.H"

    27 #include "ImumDisconnectOperation.h"

    28 #include <imum.rsg>

    29 #include <imapcmds.h>

    30 #include "IMAPPRGR.H"

    31 #include "ImumMtmLogging.h"

    32 #include "ImumPanic.h"

    33 #include "IMSSettingsNoteUi.h"

    34 

    35 const TInt KCopyMoveLocalOpPriority = CActive::EPriorityStandard;

    36 

    37 

    38 CImap4CopyMoveLocalOp* CImap4CopyMoveLocalOp::NewL(

    39     CImumInternalApi& aMailboxApi,

    40     TRequestStatus& aStatus,

    41     MMsvProgressReporter& aReporter,

    42     const CMsvEntrySelection& aSel,

    43     TMsvId aTargetId,

    44     TBool aCopy)

    45     {

    46     IMUM_STATIC_CONTEXT( CImap4CopyMoveLocalOp::NewL, 0, mtm, KImumMtmLog );

    47     IMUM_IN();

    48     

    49     CImap4CopyMoveLocalOp* op = new(ELeave) CImap4CopyMoveLocalOp(

    50         aMailboxApi, aStatus, aReporter, aTargetId, aCopy);

    51     CleanupStack::PushL(op);

    52     op->ConstructL(aSel);

    53     CleanupStack::Pop();

    54     IMUM_OUT();

    55     return op;

    56     }

    57 

    58 CImap4CopyMoveLocalOp::~CImap4CopyMoveLocalOp()

    59     {

    60     IMUM_CONTEXT( CImap4CopyMoveLocalOp::~CImap4CopyMoveLocalOp, 0, KImumMtmLog );

    61     IMUM_IN();

    62     

    63     delete iLocalSel;

    64     delete iRemoteSel;

    65     IMUM_OUT();

    66     }

    67 

    68 const TDesC8& CImap4CopyMoveLocalOp::GetErrorProgressL(TInt aError)

    69     {

    70     IMUM_CONTEXT( CImap4CopyMoveLocalOp::GetErrorProgressL, 0, KImumMtmLog );

    71     IMUM_IN();

    72     

    73     // Called to report a leave in DoRunL()

    74     if(!iProgressBuf().iGenericProgress.iErrorCode)

    75         {

    76         TImap4CompoundProgress& prog = iProgressBuf();

    77         if(iCopying)

    78             {

    79             prog.iGenericProgress.iOperation = TImap4GenericProgress::ECopyToLocal;

    80             prog.iGenericProgress.iState = TImap4GenericProgress::ECopying;

    81             }

    82         else

    83             {

    84             prog.iGenericProgress.iOperation = TImap4GenericProgress::EMoveToLocal;

    85             prog.iGenericProgress.iState = TImap4GenericProgress::EMoving;

    86             }

    87 

    88         prog.iGenericProgress.iErrorCode = aError;

    89         }

    90     IMUM_OUT();

    91     return iProgressBuf;

    92     }

    93 

    94 void CImap4CopyMoveLocalOp::DoRunL()

    95     {

    96     IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoRunL, 0, KImumMtmLog );

    97     IMUM_IN();

    98     

    99     TInt returnValue( KErrNone );

   100     switch(iState)

   101         {

   102         case ELocalMsgs:

   103             // Local copy complete

   104             returnValue = GetOperationCompletionCodeL();

   105             if( returnValue != KErrNone )

   106                 {

   107                 // Failed to copy local messages.

   108                 iState = EIdle;

   109                 CompleteObserver( returnValue );

   110                 }

   111             else

   112                 {

   113                 DoRemoteFetchL();

   114                 }

   115             break;

   116         case ERemoteMsgs:

   117             // Remote fetch complete.

   118             iState = EIdle;

   119             CompleteObserver();

   120             break;

   121         case EIdle:

   122         default:

   123             break;

   124         }

   125     IMUM_OUT();

   126     }

   127 

   128 CImap4CopyMoveLocalOp::CImap4CopyMoveLocalOp(

   129     CImumInternalApi& aMailboxApi,

   130     TRequestStatus& aStatus,

   131     MMsvProgressReporter& aReporter,

   132     TMsvId aTargetId,

   133     TBool aCopy)

   134     :

   135     CImumDiskSpaceObserverOperation(aMailboxApi, KCopyMoveLocalOpPriority, aStatus, aReporter),

   136     iCopying(aCopy),

   137     iTarget(aTargetId)

   138     {

   139     IMUM_CONTEXT( CImap4CopyMoveLocalOp::CImap4CopyMoveLocalOp, 0, KImumMtmLog );

   140     IMUM_IN();

   141     IMUM_OUT();

   142     

   143     }

   144 

   145 void CImap4CopyMoveLocalOp::ConstructL(const CMsvEntrySelection& aSel)

   146     {

   147     IMUM_CONTEXT( CImap4CopyMoveLocalOp::ConstructL, 0, KImumMtmLog );

   148     IMUM_IN();

   149     

   150     __ASSERT_DEBUG(aSel.Count(),

   151         User::Panic(KImumMtmUiPanic,EPanicSelectionEmpty));

   152     if ( aSel.Count() == 0 )

   153         {

   154         User::Leave( KErrNotSupported );

   155         }

   156     BaseConstructL(KUidMsgTypeIMAP4);

   157     CMsvEntry* centry = iMsvSession.GetEntryL(aSel[0]);

   158     iService = centry->OwningService();

   159     delete centry;

   160     SortMessageSelectionL(aSel);

   161     DoLocalCopyMoveL();

   162     IMUM_OUT();

   163     }

   164 

   165 void CImap4CopyMoveLocalOp::SortMessageSelectionL(const CMsvEntrySelection& aSel)

   166     {

   167     IMUM_CONTEXT( CImap4CopyMoveLocalOp::SortMessageSelectionL, 0, KImumMtmLog );

   168     IMUM_IN();

   169     

   170     // Sort messages into complete and incomplete selections.

   171     __ASSERT_DEBUG(!iLocalSel,

   172         User::Panic(KImumMtmUiPanic,EPanicSelAlreadyCreated));

   173     iLocalSel = new(ELeave) CMsvEntrySelection;

   174     __ASSERT_DEBUG(!iRemoteSel,

   175         User::Panic(KImumMtmUiPanic,EPanicSelAlreadyCreated));

   176     iRemoteSel = new(ELeave) CMsvEntrySelection;

   177 

   178     TInt err;

   179     TMsvId id;

   180     TMsvId service;

   181     TMsvEntry tentry;

   182     for(TInt count=0; count<aSel.Count(); count++)

   183         {

   184         id = aSel[count];

   185         err = iMsvSession.GetEntry(id, service, tentry);

   186         if(KErrNone == err)

   187             {

   188             if(tentry.Complete())

   189                 {

   190                 iLocalSel->AppendL(id);

   191                 }

   192             else

   193                 {

   194                 iRemoteSel->AppendL(id);

   195                 }

   196             }

   197         }

   198     IMUM_OUT();

   199     }

   200 

   201 void CImap4CopyMoveLocalOp::DoLocalCopyMoveL()

   202     {

   203     IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoLocalCopyMoveL, 0, KImumMtmLog );

   204     IMUM_IN();

   205     

   206     iState = ELocalMsgs;

   207     iStatus = KRequestPending;

   208     if(iLocalSel->Count())

   209         {

   210         CMsvEntry* centry = iMsvSession.GetEntryL((*iLocalSel)[0]);

   211         CleanupStack::PushL(centry);

   212         TMsvId parent = centry->Entry().Parent();

   213         centry->SetEntryL(parent);

   214         __ASSERT_DEBUG(!iOperation,

   215             User::Panic(KImumMtmUiPanic,EPanicOpAlreadySet));

   216         delete iOperation;

   217         iOperation = NULL;

   218         iOperation = MsvEmailMtmUiUtils::DoCEntryCopyMoveL(

   219             *centry, *iLocalSel, iTarget, iStatus, iCopying);

   220         CleanupStack::PopAndDestroy(); // centry

   221         }

   222     else

   223         {

   224         CompleteThis();

   225         }

   226     SetActive();

   227     IMUM_OUT();

   228     }

   229 

   230 void CImap4CopyMoveLocalOp::DoRemoteFetchL()

   231     {

   232     IMUM_CONTEXT( CImap4CopyMoveLocalOp::DoRemoteFetchL, 0, KImumMtmLog );

   233     IMUM_IN();

   234     

   235     TInt numMsgs = iRemoteSel->Count();

   236     iState = ERemoteMsgs;

   237     if(numMsgs)

   238         {

   239         CMsvEntry* centry = iMsvSession.GetEntryL(iService);

   240         TBool doIt = centry->Entry().Connected();

   241         delete centry;

   242         if(!doIt)

   243             {

   244             numMsgs += iLocalSel->Count();

   245             iReporter.MakeProgressVisibleL(EFalse);

   246 

   247             // Prompt user before connecting.

   248             TInt queryResouce =  numMsgs > 1 ?

   249                 R_EMAIL_FETCH_MESSAGES_BEFORE_COPY_QUERY :

   250                 R_EMAIL_FETCH_MESSAGE_BEFORE_COPY_QUERY;

   251             doIt = CIMSSettingsNoteUi::ShowQueryL(

   252                 queryResouce, R_EMAIL_CONFIRMATION_QUERY );

   253             }

   254         if(doIt)

   255             {

   256             iReporter.MakeProgressVisibleL(ETrue);

   257             iStatus = KRequestPending;

   258             delete iOperation;

   259             iOperation = NULL;

   260             TImImap4GetMailInfo getMailInfo;

   261             getMailInfo.iMaxEmailSize = KMaxTInt32;

   262             getMailInfo.iGetMailBodyParts = EGetImap4EmailBodyTextAndAttachments;

   263             getMailInfo.iDestinationFolder = iTarget;

   264 

   265             iOperation = CImap4FetchOp::NewL(

   266                 iMailboxApi,

   267                 iStatus,

   268                 iReporter,

   269                 iService,

   270                 (iCopying?KIMAP4MTMCopyMailSelectionWhenAlreadyConnected:KIMAP4MTMMoveMailSelectionWhenAlreadyConnected),

   271                 getMailInfo,

   272                 *iRemoteSel);

   273             }

   274         }

   275     if(iStatus != KRequestPending)

   276         {

   277         CompleteThis();

   278         }

   279     SetActive();

   280     IMUM_OUT();

   281     }

   282