/*

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

*     Copies/Moves message store from source drive to target drive

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include "MceSettingsMovemsgs.h"

#include "MceSettingsUtils.h"

#include <systemwarninglevels.hrh>

#include <msvapi.h>

#include <e32cmn.h>

#include <msvipc.h>

#include <StringLoader.h>

#include <MceSettings.rsg>

#include <aknnotewrappers.h>

// CONSTANTS

#ifdef _DEBUG

_LIT( KPanicText, "MceSettings.dll" );

enum TMcesettingsPanic

	{

	EMceSingleOpWatcherAlreadyActive = 1,

	EMceSingleOpWatcherOperationAlreadySet,

	EMceSingleOpWatcherOperationNull

	};

#endif

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

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

// CMceMessageTransHandler::Constructor

//

//

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

CMceMessageTransHandler::CMceMessageTransHandler(

    MMceMsgTransHandlerObserver& aOwner, CMsvSession* aSession, TInt aTargetDrive,

    TInt aSourceDrive, TBool aDeleteCopiedStore )

: CActive( KMsgTransHndlrPriority ), iOwner( aOwner ), iSession( aSession ),

        iTargetDrive(aTargetDrive ), iSourceDrive( aSourceDrive ),

        iDeleteCopiedStore( aDeleteCopiedStore ),

        iState( EStateCopying )

    {

    __DECLARE_NAME(_S("CMceMessageTransHandler") );

    CActiveScheduler::Add( this );

    }

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

// CMceMessageTransHandler::Constructor

//

//

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

CMceMessageTransHandler  *CMceMessageTransHandler::NewL(

    MMceMsgTransHandlerObserver& aOwner, CMsvSession* aSession,

    TInt aTargetDrive, TInt aSourceDrive, TBool aDeleteCopiedStore )

    {

    CMceMessageTransHandler* self=new ( ELeave ) CMceMessageTransHandler(

            aOwner,aSession,aTargetDrive,aSourceDrive,aDeleteCopiedStore);

    CleanupStack::PushL( self );

    self->ConstructL(); // should be consts in next release

    CleanupStack::Pop( self );

    return self;

    }

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

// CMceMessageTransHandler::ConstructL

// Creates delete thread and transfer thread

//

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

void CMceMessageTransHandler::ConstructL()

    {

    /* Nothing */;

    }

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

// CMceMessageTransHandler::Destructor

//

//

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

CMceMessageTransHandler::~CMceMessageTransHandler()

    {

    Cancel();

    delete iOperation;

    iOperation = NULL;

    }

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

// CMceMessageTransHandler::SetOperation

// --- Setter ---

// Must only be called once during the lifetime of a CMsvSingleOpWatcher object.

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

void CMceMessageTransHandler::SetOperation( CMsvOperation* aOperation )

    {

    __ASSERT_DEBUG( !IsActive(), User::Panic( KPanicText, EMceSingleOpWatcherAlreadyActive ) );

    __ASSERT_DEBUG( !iOperation, User::Panic( KPanicText, EMceSingleOpWatcherOperationAlreadySet ) );

    __ASSERT_DEBUG( aOperation, User::Panic( KPanicText, EMceSingleOpWatcherOperationNull ) );

    // Delete the old operation

    delete iOperation;

    iOperation = NULL;

    // Take ownership of operation and set our active status so we're handled 

    // by the active scheduler.

    iOperation = aOperation;

    SetActive();

    }

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

// CMsvSingleOpWatcher::Operation

// --- Accessor ---

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

//

CMsvOperation& CMceMessageTransHandler::Operation() const

    {

    __ASSERT_DEBUG( iOperation, User::Panic( KPanicText, EMceSingleOpWatcherOperationNull ) );

    return *iOperation;

    }

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

// CMceMessageTransHandler::DoCancel

// --- From CActive ---

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

//

void CMceMessageTransHandler::DoCancel()        

    {

    // Pass on cancel 

    iOperation->Cancel();

    }

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

// CMceMessageTransHandler::RunL

// Calls TransferCompleteL and

// sets message store drive on the message server

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

void CMceMessageTransHandler::RunL()

    {

    TInt err = iStatus.Int();

    if (err == KErrNone)

    	{

    	err = ProgressErrorL();

    	}  

    if ( err != KErrNone )

        {

        // Copy operation did not succeed

        HBufC* text = StringLoader::LoadLC( R_MCE_SETTINGS_CANNOT_MOVE_STORE, 

                               CCoeEnv::Static() );

        CAknErrorNote* note = new ( ELeave ) CAknErrorNote();

        note->ExecuteLD( *text );

        CleanupStack::PopAndDestroy( text );

        }

    switch ( iState )

        {

        case EStateCopying:

            // Inform client of watcher that the operation has completed

            iOwner.CopyCompleteL( err );  

            if ( err == KErrNone && iDeleteCopiedStore )

                {

                // Only delete if there is no error copying

                delete iOperation;

                iOperation = NULL;                

                // Delete the old store

                iOperation = iSession->DeleteStoreL( iSourceDrive, iStatus );

                iState = EStateDeleting;

                SetActive();

                }

            else

                iOwner.TransferCompleteL( err );

            break;

        case EStateDeleting:

            // Check whether operation worked OK

            iOwner.TransferCompleteL( err );

            break;

        default:

            break;

        }    

    }

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

// CMceMessageTransHandler::Progress

// return % copied so far

//

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

TInt CMceMessageTransHandler::ProgressL() const

    {

    // Let's say everything up to the actual copy is the first 1%,

    // the copying is the next 98% and everything else the last 1%.

    const TInt KPreCopyPercentage = 1;

    const TInt KPostCopyPercentage = 1;

    const TInt KHundredPercentage = 100;

    const TInt KCopyPercentage = KHundredPercentage - KPreCopyPercentage - KPostCopyPercentage;

    if ( iState == EStateCopying )

        {

        // Get the progress

        TMsvCopyProgress copyProgress;

        TPckgC<TMsvCopyProgress> progressPackage( copyProgress );

        progressPackage.Set( iOperation->ProgressL() );

        copyProgress = progressPackage();	    

        if ( copyProgress.iError == KErrNone )

        	{

        	if ( copyProgress.iState == TMsvCopyProgress::ENotYetStarted )

        		{

        		return 0; // Nothing done yet

        		}

        	else if ( copyProgress.iState < TMsvCopyProgress::ECopyStore )

        		{

        		return KPreCopyPercentage; // Started, but not yet copying

        		}

        	else if ( copyProgress.iState == TMsvCopyProgress::ECopyStore )

        		{

        		// Copying, so return percentage of copy done + pre-copy percentage

        		return ( ( ( copyProgress.iCurrent + 1 ) * KCopyPercentage ) 

        		                                                / copyProgress.iTotal ) + KPreCopyPercentage;

        		}

        	else if ( copyProgress.iState == TMsvCopyProgress::ECompleted && !iDeleteCopiedStore )

        		{

        		// Finished copying and no delete to do - All done!

        		return KHundredPercentage;

        		}

        	else

        		{

        		// Copy is done but there's still more to do					

        		return KHundredPercentage - KPostCopyPercentage;

        		}

        	}

        else

        	{

        	return 0; // Error

        	}

        }

    else // EStateDeleting

    	{

    	TMsvDeleteProgress deleteProgress;

    	TPckgC<TMsvDeleteProgress> progressPackage( deleteProgress );

    	progressPackage.Set( iOperation->ProgressL() );

    	deleteProgress = progressPackage();

    	if ( deleteProgress.iError != KErrNone )

    		{

    		if ( deleteProgress.iState == TMsvDeleteProgress::ECompleted )

    			{

    			// Finsihed copying and deleting - All done!

    			return KHundredPercentage;

    			}

    		else

    			{

    			// Still deleting

    			return KHundredPercentage - KPostCopyPercentage;

    			}					

    		}

    	else

		{

		return 0; // Error

		}

    	}

    }

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

// TInt CMceMessageTransHandler::ProgressErrorL() const

//

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

TInt CMceMessageTransHandler::ProgressErrorL() const

    {

    if ( iState == EStateCopying )

        {

        TMsvCopyProgress copyProgress;

        TPckgC<TMsvCopyProgress> copyProgressPckg( copyProgress );

        copyProgressPckg.Set( iOperation->ProgressL() );

        return copyProgressPckg().iError;

        }

    else // EStateDeleting

    	{

    	TMsvDeleteProgress deleteProgress;

    	TPckgC<TMsvDeleteProgress> deleteProgressPckg( deleteProgress );

    	deleteProgressPckg.Set( iOperation->ProgressL() );

    	return deleteProgressPckg().iError;

    	}	

    }

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

// Called by the framework if RunL leaves

//

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

TInt CMceMessageTransHandler::RunError( TInt )

    {

    return KErrNone;

    }    

// End of file