/*

* Copyright (c) 2006 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: 

*       Fetch message(s) operation, using client MTM Get Mail API

*

*/

#include <eikenv.h>

#include <StringLoader.h>

#include <MsvPrgReporter.h>

#include <ImumUtils.rsg>

#include "ImumPanic.h"

#include "MsvPop3FetchOperation.h"

#include "MsvPop3ConnectOp.h"

#include "MsvConnectionValidation.h"

#include "MsvEmailConnectionProgressProvider.h"

#include "EmailUtils.H"

#include "ImumDisconnectOperation.h"

// Constants and defines

const TInt KFetchOpPriority = CActive::EPriorityStandard;

// ----------------------------------------------------------------------------

// NewL

// ----------------------------------------------------------------------------

CMsvPop3FetchOperation* CMsvPop3FetchOperation::NewL(

    CImumInternalApi& aMailboxApi,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TInt aFunctionId,

    TMsvId aService,

    const TImPop3GetMailInfo& aGetMailInfo,

    const CMsvEntrySelection& aSel)

    {

    IMUM_STATIC_CONTEXT( CMsvPop3FetchOperation::NewL, 0, mtm, KImumMtmLog );

    IMUM_IN();

    CMsvPop3FetchOperation* op = new(ELeave) CMsvPop3FetchOperation(

        aMailboxApi,

        aObserverRequestStatus,

        aReporter,

        aFunctionId,

        aService,

        aGetMailInfo);

    CleanupStack::PushL(op);

    op->ConstructL(aSel);

    CleanupStack::Pop(); // op

    IMUM_OUT();

    return op;

    }

// ----------------------------------------------------------------------------

//Overloaded NewL for partial fetch operation

// ----------------------------------------------------------------------------

CMsvPop3FetchOperation* CMsvPop3FetchOperation::NewL(

    CImumInternalApi& aMailboxApi,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TInt aFunctionId,

    TMsvId aService,

    const TImPop3GetMailInfo& aGetMailInfo,

    const CMsvEntrySelection& aSel,

    TInt aLimit)

    {

    IMUM_STATIC_CONTEXT( CMsvPop3FetchOperation::NewL, 0, mtm, KImumMtmLog );

    IMUM_IN();

    CMsvPop3FetchOperation* op = new(ELeave) CMsvPop3FetchOperation(

        aMailboxApi,

        aObserverRequestStatus,

        aReporter,

        aFunctionId,

        aService,

        aGetMailInfo,

        aLimit);

    CleanupStack::PushL(op);

    op->ConstructL(aSel);

    CleanupStack::Pop(); // op

    IMUM_OUT();

    return op;

    }

// ----------------------------------------------------------------------------

// ~CMsvPop3FetchOperation

// ----------------------------------------------------------------------------

CMsvPop3FetchOperation::~CMsvPop3FetchOperation()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::~CMsvPop3FetchOperation, 0, KImumMtmLog );

    IMUM_IN();

    delete iFetchErrorProgress;

    delete iSelection;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// ProgressL

// ----------------------------------------------------------------------------

const TDesC8& CMsvPop3FetchOperation::ProgressL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::ProgressL, 0, KImumMtmLog );

    IMUM_IN();

    if(iFetchErrorProgress && (iState == EStateIdle))

        {

        IMUM_OUT();

        // Completed, but with an error during fetch.

        return *iFetchErrorProgress;

        }

    IMUM_OUT();

    return CImumOnlineOperation::ProgressL();

    }

// ----------------------------------------------------------------------------

// ConstructL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::ConstructL(const CMsvEntrySelection& aSel)

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::ConstructL, 0, KImumMtmLog );

    IMUM_IN();

    BaseConstructL(KUidMsgTypePOP3);

    iSelection = aSel.CopyL();

    iSelection->InsertL(0, iService);

    // For Get Mail API, first selection element must be service.

    DoConnectL();

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// DoConnectL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::DoConnectL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::DoConnectL, 0, KImumMtmLog );

    IMUM_IN();

    iState = EStateConnecting;

    iStatus = KRequestPending;

    CMsvPop3ConnectOp* connOp = CMsvPop3ConnectOp::NewL(

        iStatus,

        iReporter,

        iService,

        0 );

    // when connecting for the fetch operation, don't let connect operation to do fetch,

    // because we do it by ourself. That's why give 0 to connect operation.

    delete iOperation;

    iOperation = connOp;

    //We always leave connection on after fetching.

    //If fetching from off line state and want to disconnect afterwards,

    //checks are needed here.

    iDisconnect = EFalse;

    TMsvEntry serviceEntry;

    TMsvId serviceId;

    if ( iMsvSession.GetEntry( Service(), serviceId, serviceEntry ) == KErrNone )

        {

        if ( !serviceEntry.Connected() )

        	{

        	HBufC* text = StringLoader::LoadLC(

        			R_EMAIL_CONNECTING_SERVER, serviceEntry.iDetails, iEikEnv );

        	iReporter.SetTitleL( *text );

        	CleanupStack::PopAndDestroy( text );

        	}

        }   	    	

    // Go active ourselves.

    SetActive();

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// DoFetchL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::DoFetchL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::DoFetchL, 0, KImumMtmLog );

    IMUM_IN();

    iState = EStateFetching;

    // Switch operations.

    delete iOperation;

    iOperation = NULL;

    iStatus = KRequestPending;

    // Filters are not used when performing 'fetch' operation, use normal getmail info instead

    TPckg<TImPop3GetMailInfo> param(iGetMailInfo);

    InvokeClientMtmAsyncFunctionL(iFunctionId, *iSelection, iService, param );

    SetActive();

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// DoDisconnectL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::DoDisconnectL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::DoDisconnectL, 0, KImumMtmLog );

    IMUM_IN();

    iState = EStateDisconnecting;

    TMsvId temp;

    TMsvEntry entry;

    const TInt err = iMsvSession.GetEntry(iService, temp, entry);

    if( (iDisconnect) && (err==KErrNone) && (entry.Connected()) )

        {

        delete iOperation;

        iOperation = NULL;

        iStatus = KRequestPending;

        iOperation = CImumDisconnectOperation::NewL(

            iMailboxApi,

            iStatus,

            iReporter,

            iService,

            KPOP3MTMDisconnect,

            KUidMsgTypePOP3);

        }

    else

        {

        CompleteThis();

        }

    SetActive();

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CMsvPop3FetchOperation

// ----------------------------------------------------------------------------

CMsvPop3FetchOperation::CMsvPop3FetchOperation(

    CImumInternalApi& aMailboxApi,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TInt aFunctionId,

    TMsvId aService,

    const TImPop3GetMailInfo& aGetMailInfo)

    :

    CImumDiskSpaceObserverOperation(

    aMailboxApi,

    KFetchOpPriority,

    aObserverRequestStatus,

    aReporter),

    iFunctionId(aFunctionId),

    iGetMailInfo(aGetMailInfo)

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::CMsvPop3FetchOperation, 0, KImumMtmLog );

    IMUM_IN();

    iService = aService;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// CMsvPop3FetchOperation. Overloaded constructor for

// partial fetch operation

// ----------------------------------------------------------------------------

CMsvPop3FetchOperation::CMsvPop3FetchOperation(

    CImumInternalApi& aMailboxApi,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter,

    TInt aFunctionId,

    TMsvId aService,

    const TImPop3GetMailInfo& aGetMailInfo,

    TInt aLimit)

    :

    CImumDiskSpaceObserverOperation(

    aMailboxApi,

    KFetchOpPriority,

    aObserverRequestStatus,

    aReporter),

    iFunctionId(aFunctionId),

    iGetMailInfo(aGetMailInfo),

    iPopulateLimit( aLimit )

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::CMsvPop3FetchOperation, 0, KImumMtmLog );

    IMUM_IN();

    iService = aService;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// RunL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::RunL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::RunL, 0, KImumMtmLog );

    IMUM_IN();

    TRAP(iError, DoRunL()); // CSI: 86 # Needed here to properly handle error situations

    if(iError != KErrNone)

        {

        // Need to ensure we disconnect if we have connected.

        if( (iError == KErrNoMemory) || (iState == EStateDisconnecting) )

            {

            // OOM and/or failed to create disconnect operation. Call StopService()

            iMsvSession.StopService(iService);

            // Ignore return, nothing we can do.

            }

        else if( (iState == EStateFetching) && (iDisconnect) )

            {

            // Failed to start fetch operation. Need to disconnect.

            __ASSERT_DEBUG(!iFetchErrorProgress,

                User::Panic(KImumMtmUiPanic,EPop3MtmUiOpAlreadyHaveProgErr));

            TPckgBuf<TPop3Progress>* progPkg = new TPckgBuf<TPop3Progress>; // CSI: 62 # We want to avoid leaves.

            iFetchErrorProgress = progPkg;

            if(iFetchErrorProgress)

                {

                TPop3Progress& errProg = (*progPkg)();

                errProg.iPop3Progress = TPop3Progress::EPopPopulating;

                errProg.iTotalMsgs = 0;

                errProg.iMsgsToProcess = 0;

                errProg.iBytesDone = 0;

                errProg.iTotalBytes = 0;

                errProg.iErrorCode = iError;

                errProg.iPop3SubStateProgress = TPop3Progress::EPopPopulating;

                errProg.iServiceId = iService;

                }

            SetActive();

            CompleteThis();     // Next DoRunL() will attempt to disconnect.

            IMUM_OUT();

            return;

            }

        // Notify observer we have finished.

        CompleteObserver();

        }

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// DoCancel

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::DoCancel()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::DoCancel, 0, KImumMtmLog );

    IMUM_IN();

    CImumOnlineOperation::DoCancel();

    if(iState == EStateFetching)

        {

        // Cancelled while fetching. Need to disconnect.

        iMsvSession.StopService(iService);

        // Ignore return, nothing we can do.

        }

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// DoRunL

// ----------------------------------------------------------------------------

void CMsvPop3FetchOperation::DoRunL()

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::DoRunL, 0, KImumMtmLog );

    IMUM_IN();

    switch(iState)

        {

        case EStateConnecting:

            {

            // Connect complete.

            TBool connected = STATIC_CAST(CMsvPop3ConnectOp*,iOperation)->Connected();

            if(!connected)

                {

                // Connect failed.

                CompleteObserver( KErrCouldNotConnect );

                IMUM_OUT();

                return;

                }

            DoFetchL();

            }

            break;

        case EStateFetching:

            // Fetch complete.

            {

            TInt err = GetOperationCompletionCodeL();

            if(err != KErrNone)

                {

                __ASSERT_DEBUG(!iFetchErrorProgress,

                    User::Panic(KImumMtmUiPanic,EPop3MtmUiOpAlreadyHaveProgErr));

                TPckgBuf<TPop3Progress> paramPack;

                paramPack.Copy( iOperation->ProgressL() );

                TPop3Progress& progress = paramPack();

                progress.iErrorCode = err;

                iFetchErrorProgress = paramPack.AllocL();

                }

            DoDisconnectL();

            }

            break;

        case EStateDisconnecting:

            // Disconnect complete.

            iState = EStateIdle;

            CompleteObserver();

            break;

        default:

            User::Panic(KImumMtmUiPanic,EPop3MtmUiOpUnknownState);

            break;

        }

    if(iOperation)

        iMtm = iOperation->Mtm();

    else

        iMtm = KUidMsgTypePOP3;

    IMUM_OUT();

    }

// ----------------------------------------------------------------------------

// GetErrorProgressL

// ----------------------------------------------------------------------------

const TDesC8& CMsvPop3FetchOperation::GetErrorProgressL(TInt aError)

// Called when DoRunL() leaves.

    {

    IMUM_CONTEXT( CMsvPop3FetchOperation::GetErrorProgressL, 0, KImumMtmLog );

    IMUM_IN();

    iError = aError;

    if(iFetchErrorProgress)

        {

        delete iFetchErrorProgress;

        iFetchErrorProgress = NULL;

        }

    TPckgBuf<TPop3Progress> paramPack;

    TPop3Progress& progress = paramPack();

    progress.iPop3Progress = TPop3Progress::EPopConnecting;

    progress.iTotalMsgs = 0;

    progress.iMsgsToProcess = 0;

    progress.iBytesDone = 0;

    progress.iTotalBytes = 0;

    progress.iErrorCode = iError;

    switch(iState)

        {

        case EStateConnecting:  // Should never get this, so treat as next state.

        case EStateFetching:

            if(iOperation)

                {

                paramPack.Copy( iOperation->ProgressL() );

                }

            else

                {

                progress.iPop3Progress = TPop3Progress::EPopPopulating;

                }

            break;

        case EStateDisconnecting:

            progress.iPop3Progress = TPop3Progress::EPopDisconnecting;

            break;

        default:

            break;

        }

    iFetchErrorProgress = paramPack.AllocL();

    IMUM_OUT();

    return *iFetchErrorProgress;

    }

// End of File