/*

* 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: 

*       Common base class for email online operations

*

*/

#include <eikenv.h>

#include <eikrutil.h>

#include <MsvPrgReporter.h>

#include <MTMStore.h>

#include <mtmuibas.h>

#include <ImumInternalApi.h>        // CImumInternalApi

#include "ImumOnlineOperation.h"

#include "ImumPanic.h"

#include "ImumMtmLogging.h"

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

// CImumOnlineOperation::~CImumOnlineOperation()

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

//

CImumOnlineOperation::~CImumOnlineOperation()

    {

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

    IMUM_IN();

    Cancel();

    delete iOperation;

    if(iMtmUi)

        {

        iReporter.MtmStore().ReleaseMtmUi(iMtmUi->Type());

        }

    IMUM_OUT();

    }

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

// CImumOnlineOperation::ProgressL()

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

//

const TDesC8& CImumOnlineOperation::ProgressL()

    {

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

    IMUM_IN();

    IMUM_OUT();

    if(iError != KErrNone)

        {

        return GetErrorProgressL(iError);

        }

    else if(iOperation)

        {

        return iOperation->ProgressL();

        }

    return iDummyProg;

    }

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

// CImumOnlineOperation::CImumOnlineOperation()

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

//

CImumOnlineOperation::CImumOnlineOperation(

    CImumInternalApi& aMailboxApi,

    TInt aPriority,

    TRequestStatus& aObserverRequestStatus,

    MMsvProgressReporter& aReporter)

    :

    CMsvOperation(

        aMailboxApi.MsvSession(),

        aPriority,

        aObserverRequestStatus),

    iReporter(aReporter),

    iMailboxApi( aMailboxApi ),

    iEikEnv(CEikonEnv::Static())

    {

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

    IMUM_IN();

    IMUM_OUT();

    }

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

// CImumOnlineOperation::BaseConstructL()

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

//

void CImumOnlineOperation::BaseConstructL(TUid aMtmType)

    {

    IMUM_CONTEXT( CImumOnlineOperation::BaseConstructL, 0, KImumMtmLog );

    IMUM_IN();

    iObserverRequestStatus = KRequestPending;

    CActiveScheduler::Add(this);

    iMtmUi = &(iReporter.MtmStore().ClaimMtmUiL(aMtmType));

    iMtm = aMtmType;

    IMUM_OUT();

    }

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

// CImumOnlineOperation::DoCancel()

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

//

void CImumOnlineOperation::DoCancel()

    {

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

    IMUM_IN();

    if(iOperation)

        {

        iOperation->Cancel();

        }

    CompleteObserver();

    IMUM_OUT();

    }

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

// CImumOnlineOperation::RunL()

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

//

void CImumOnlineOperation::RunL()

    {

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

    IMUM_IN();

    // First do a disk space check, so the operation can continue

    iError = DoDiskSpaceCheckL();

    // If still free disk space, the actual operation can be continued

    if ( iError == KErrNone )

        {

        DoRunL();

        }

	else

		{

		User::Leave( iError );

		}

    IMUM_OUT();

    }

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

// CImumOnlineOperation::RunError()

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

//

TInt CImumOnlineOperation::RunError( TInt aError )

    {

    IMUM_CONTEXT( CImumOnlineOperation::RunError, 0, KImumMtmLog );

    IMUM_IN();

    IMUM1( 0, "RunL error %d", aError );

    CompleteObserver( aError );

    IMUM_OUT();

     // RunError must return KErrNone to active sheduler.

     // We return the error, since we do not fully handle the error

     // We may want the framework to show some notes etc...

    return aError;

    }

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

// CImumOnlineOperation::CompleteObserver()

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

//

void CImumOnlineOperation::CompleteObserver( TInt aStatus /*= KErrNone*/ )

    {

    IMUM_CONTEXT( CImumOnlineOperation::CompleteObserver, 0, KImumMtmLog );

    IMUM_IN();

    TRequestStatus* status = &iObserverRequestStatus;

    User::RequestComplete(status, aStatus);

    IMUM_OUT();

    }

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

// CImumOnlineOperation::CompleteThis()

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

//

void CImumOnlineOperation::CompleteThis()

    {

    IMUM_CONTEXT( CImumOnlineOperation::CompleteThis, 0, KImumMtmLog );

    IMUM_IN();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    IMUM_OUT();

    }

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

// CImumOnlineOperation::GetOperationCompletionCodeL()

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

//

TInt CImumOnlineOperation::GetOperationCompletionCodeL()

    {

    IMUM_CONTEXT( CImumOnlineOperation::GetOperationCompletionCodeL, 0, KImumMtmLog );

    IMUM_IN();

    if(iStatus.Int() != KErrNone)

        {

        IMUM_OUT();

        return iStatus.Int();

        }

    __ASSERT_DEBUG( iMtmUi, User::Panic( KImumMtmUiPanic,EPanicOpNoMtmUi ) );

    TBuf<CBaseMtmUi::EProgressStringMaxLen> retString;

    TInt totalEntryCount = 0;

    TInt entriesDone = 0;

    TInt currentEntrySize = 0;

    TInt currentBytesTrans = 0;

    IMUM_OUT();

    return iMtmUi->GetProgress(

        ProgressL(),

        retString,

        totalEntryCount,

        entriesDone,

        currentEntrySize,

        currentBytesTrans);

    }

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

// CImumOnlineOperation::InvokeClientMtmAsyncFunctionL()

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

//

void CImumOnlineOperation::InvokeClientMtmAsyncFunctionL(

    TInt aFunctionId,

    TMsvId aEntryId,

    TMsvId aContextId,

    const TDesC8& aParams)

    {

    IMUM_CONTEXT( CImumOnlineOperation::InvokeClientMtmAsyncFunctionL, 0, KImumMtmLog );

    IMUM_IN();

    CMsvEntrySelection* sel = new(ELeave) CMsvEntrySelection;

    CleanupStack::PushL(sel);

    sel->AppendL(aEntryId);

    InvokeClientMtmAsyncFunctionL(aFunctionId, *sel, aContextId, aParams);

    CleanupStack::PopAndDestroy(); // sel

    IMUM_OUT();

    }

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

// CImumOnlineOperation::InvokeClientMtmAsyncFunctionL()

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

//

void CImumOnlineOperation::InvokeClientMtmAsyncFunctionL(

    TInt aFunctionId,

    const CMsvEntrySelection& aSel,

    TMsvId aContextId,

    const TDesC8& aParams)

    {

    IMUM_CONTEXT( CImumOnlineOperation::InvokeClientMtmAsyncFunctionL, 0, KImumMtmLog );

    IMUM_IN();

    __ASSERT_DEBUG(iMtmUi, User::Panic( KImumMtmUiPanic,EPanicOpNoMtmUi));

    CBaseMtm& mtm = iMtmUi->BaseMtm();

    mtm.SwitchCurrentEntryL(aContextId);

    HBufC8* params = aParams.AllocLC();

    TPtr8 ptr(params->Des());

    // Delete previous operation if it exist

    if ( iOperation )

        {

        delete iOperation;

        iOperation = NULL;

        }

    iOperation = mtm.InvokeAsyncFunctionL(aFunctionId, aSel, ptr, iStatus);

    CleanupStack::PopAndDestroy(); // params

    IMUM_OUT();

    }

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

// CImumOnlineOperation::ReDisplayProgressL()

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

//

void CImumOnlineOperation::ReDisplayProgressL(

    TInt /*aTitleResourceId*/, TMsvId /*aServiceId*/)

    {

    IMUM_CONTEXT( CImumOnlineOperation::ReDisplayProgressL, 0, KImumMtmLog );

    IMUM_IN();

    iReporter.MakeProgressVisibleL(ETrue);

    IMUM_OUT();

    }

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

// CImumOnlineOperation::DoDiskSpaceCheckL()

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

//

TInt CImumOnlineOperation::DoDiskSpaceCheckL()

    {

    IMUM_CONTEXT( CImumOnlineOperation::DoDiskSpaceCheckL, 0, KImumMtmLog );

    IMUM_IN();

    IMUM_OUT();

    // As default, return KErrNone

    return KErrNone;

    }