/*

 * 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".

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:  

 *

 * Description: CSimDeleteCopyOperation header

 *

 */

// INCLUDE FILES

#include <AknProgressDialog.h>  // CAknProgressDialog

#include <eikprogi.h>           // CEikProgressInfo

#include <StringLoader.h>       // StringLoader

#include <msvids.h>             // for msv entry ids

#include <msvapi.h>             // for CMsvSession

#include <smscmds.h>            // for async sms commands

#include <smut.h>               // TSmsUtilities::ServiceIdL

#include "simdeletecopyoperation.h" // for CSimDeleteCopyOperation

#include "SMSU.H"               // for CSmsMtmUi

#include "SMSU.HRH"             // for command ids

#include <defaultsimdialog.rsg>             // for resource ids

//For logging

#include "SmumLogging.h"

// CONSTANTS

const TInt KSmumNoteStringLength = 128;

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CSimDeleteCopyOperation::CSimDeleteCopyOperation(

    CMsvSession& aMsvSession,

    CSmsMtmUi& aSmsMtmUi,

    TRequestStatus& aObserverRequestStatus,

    TMsvId aDestinationId,

    CAknProgressDialog& aProgressDialog,

    TBool aCopying,

    CCoeEnv* aCoeEnv )

    :

    CMsvOperation(

        aMsvSession, 

        CActive::EPriorityStandard, 

        aObserverRequestStatus), 

    iDestinationId( aDestinationId ),

    iCopying( aCopying ),

    iSmsMtmUi( aSmsMtmUi ),

    iProgressDialog( aProgressDialog ),

    iCoeEnv( aCoeEnv ),

    iBlank( KNullDesC8 )

    {

    CActiveScheduler::Add(this);

    }

// Symbian OS default constructor can leave.

void CSimDeleteCopyOperation::ConstructL( CMsvEntrySelection* aSelection )

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::ConstructL");

    iEntrySelection = aSelection->CopyL();

    iEntryCount = iEntrySelection->Count();

    if ( iEntryCount == 0 )

        { // no entries in selection -> complete

        iStatus = KRequestPending;

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    else

        { // entries in selection -> proceed

        // Save SMS Service id to member

        CMsvEntry* root = iMsvSession.GetEntryL( KMsvRootIndexEntryId );

        CleanupStack::PushL( root );

        TSmsUtilities::ServiceIdL( *root, iSmsServiceId );

        CleanupStack::PopAndDestroy( root);

        // Load correct string to member

        if ( iEntryCount == 1 )

            {// simple string is enough

            iNoteString = StringLoader::LoadL( iCopying 

                ? R_QTN_MCE_WAIT_COPY_SIM_DLG : R_QTN_MCE_WAIT_DELETE_SIM_DLG, iCoeEnv );

            }

        else

            {// prepare string with formatting second number already

             // to string

            TBuf<KSmumNoteStringLength> tbuf;

            HBufC* buf = StringLoader::LoadL( iCopying 

                ? R_QTN_MCE_WAIT_COPY_MANY_SIM_DLG : R_QTN_MCE_WAIT_DELETE_MANY_SIM_DLG, 

                iCoeEnv );

            StringLoader::Format( tbuf, buf->Des(), 1, iEntryCount );

            delete buf;

            iNoteString = tbuf.AllocL();

            }

        // Actual operation

        CEikProgressInfo* bar = iProgressDialog.GetProgressInfoL();

        bar->SetFinalValue( iEntryCount );

        DeleteCopyNext();

        bar->SetAndDraw( iCurrentEntryIndex + 1 );

        }

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::ConstructL");

    }

// Two-phased constructor.

CSimDeleteCopyOperation* CSimDeleteCopyOperation::NewL(

    CMsvSession& aMsvSession, 

    CSmsMtmUi& aSmsMtmUi,

    TRequestStatus& aObserverRequestStatus, 

    CMsvEntrySelection* aSelection, 

    TMsvId aDestinationId,

    CAknProgressDialog& aProgressDialog,

    CCoeEnv* aCoeEnv )

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::NewL");

    CSimDeleteCopyOperation* self=new (ELeave) CSimDeleteCopyOperation(

        aMsvSession, 

        aSmsMtmUi, 

        aObserverRequestStatus, 

        aDestinationId, 

        aProgressDialog, 

        ETrue,

        aCoeEnv );

    CleanupStack::PushL(self);

    self->ConstructL( aSelection );

    CleanupStack::Pop(); // self

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::NewL");

    return self;

    }

// Two-phased constructor.

CSimDeleteCopyOperation* CSimDeleteCopyOperation::NewL(

    CMsvSession& aMsvSession, 

    CSmsMtmUi& aSmsMtmUi,

    TRequestStatus& aObserverRequestStatus, 

    CMsvEntrySelection* aSelection, 

    CAknProgressDialog& aProgressDialog,

    CCoeEnv* aCoeEnv )

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::NewL 2");

    CSimDeleteCopyOperation* self=new (ELeave) CSimDeleteCopyOperation(

        aMsvSession, 

        aSmsMtmUi, 

        aObserverRequestStatus, 

        KMsvNullIndexEntryId, 

        aProgressDialog, 

        EFalse, 

        aCoeEnv );

    CleanupStack::PushL(self);

    self->ConstructL( aSelection );

    CleanupStack::Pop(); // self

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::NewL 2");

    return self;

    }

//destructor

CSimDeleteCopyOperation::~CSimDeleteCopyOperation()

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::~CSimDeleteCopyOperation");

    Cancel();

    delete iOperation;

    delete iEntrySelection;

    delete iNoteString;

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::~CSimDeleteCopyOperation");

    }

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

// CSimDeleteCopyOperation::DeleteCopyNext()

//

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

void CSimDeleteCopyOperation::DeleteCopyNext()

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::DeleteCopyNext");

    delete iOperation;

    iOperation = NULL;

    TInt err = KErrNone;

    if ( iCanceling )

        {

#ifdef _DEBUG

        RDebug::Print(_L("CSimDeleteCopyOperation::DeleteCopyNext, canceling...") );

#endif

        err = KErrCancel;

        }

    else

        {

#ifdef _DEBUG

        RDebug::Print(_L("CSimDeleteCopyOperation::DeleteCopyNext, do next...") );

#endif

        TRAP(err, MakeNextDeleteCopyL());

        }

    // and set active

    iStatus=KRequestPending;

    SetActive();

    // if error then complete this pass with the error code

    if (err)

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete(status, err);

        }

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::DeleteCopyNext");

    }

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

// CSimDeleteCopyOperation::MakeNextDeleteCopyL()

//

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

void CSimDeleteCopyOperation::MakeNextDeleteCopyL()

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::MakeNextDeleteCopyL");

    CEikProgressInfo* bar = iProgressDialog.GetProgressInfoL();

    bar->SetAndDraw( iCurrentEntryIndex + 1 );

    // Update (if necessary) the note

    if ( iEntryCount == 1 )

        {

        iProgressDialog.SetTextL( *iNoteString );

        }

    else

        { // update the first number in string

        TBuf<KSmumNoteStringLength> tbuf;

        StringLoader::Format( tbuf, iNoteString->Des(), 0, iCurrentEntryIndex + 1 );

        iProgressDialog.SetTextL( tbuf );

        }

    // Create selection to be given to MTM

    CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection();

    CleanupStack::PushL( selection );

    // Put SMS Service id as first id in array

    selection->AppendL( iSmsServiceId );

    // ...and then current id

    selection->AppendL( iEntrySelection->At( iCurrentEntryIndex ) );

    if ( iCopying )

        {

        TPckgBuf<TMsvId> pkg( iDestinationId );

        iOperation = iSmsMtmUi.BaseMtm().InvokeAsyncFunctionL(

            ESmsMtmCommandCopyFromPhoneStore,

            *selection, pkg, iStatus );

        }

    else

        {

        TBuf8<1> foo (KNullDesC8);

        iOperation = iSmsMtmUi.BaseMtm().InvokeAsyncFunctionL(

            ESmsMtmCommandDeleteFromPhoneStore,

            *selection, foo, iStatus);

        }

    CleanupStack::PopAndDestroy( selection );

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::MakeNextDeleteCopyL");

    }

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

// CSimDeleteCopyOperation::DoCancel()

//

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

void CSimDeleteCopyOperation::DoCancel()

    {

#ifdef _DEBUG

    RDebug::Print(_L("CSimDeleteCopyOperation::DoCancel") );

#endif

    if (iOperation)

        {

        iOperation->Cancel();

        }

    TRequestStatus* status = &iObserverRequestStatus;

    User::RequestComplete(status, iStatus.Int());

    }

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

// CSimDeleteCopyOperation::CancelAfterCurrentCompleted()

//

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

void CSimDeleteCopyOperation::CancelAfterCurrentCompleted()

    {

    iCanceling = ETrue;

    }

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

// CSimDeleteCopyOperation::RunL()

//

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

void CSimDeleteCopyOperation::RunL()

    {

    SMUMLOGGER_ENTERFN("CSimDeleteCopyOperation::RunL");

    // no error handling since we immediately try with

    // the next one

    iCurrentEntryIndex++;

    if ( iCurrentEntryIndex >= iEntrySelection->Count() )

        {

        // nothing left to process, so complete the observer

        TRequestStatus* status = &iObserverRequestStatus;

        User::RequestComplete(status, iStatus.Int());

        }

    else 

        {

        // start the next pass

        DeleteCopyNext();

        }

    SMUMLOGGER_LEAVEFN("CSimDeleteCopyOperation::RunL");

    }

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

// CSimDeleteCopyOperation::ProgressL()

//

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

const TDesC8& CSimDeleteCopyOperation::ProgressL()

    {

    if (iOperation)

        return iOperation->ProgressL();

    return iBlank;

    }

//  End of File