/*

* Copyright (c) 2008 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:  Implementation of the CLcVtCmdExecutor class.

*

*/

// INCLUDE FILES

#include    "clcvtcmdexecutor.h"

#include    "mlcvtenginecommandmanager.h"

#include    <mvtengcommandhandler.h>

#include    <cvtlogger.h>

// MODULE DATA STRUCTURES

/**

* Active object to perform asynchronous commands.

* @since Series 60 2.6

*/

class CLcVtCmdExecutor::CActiveCmd

    : public CActive

    {

    public: // Constructors and destructor

        /**

        * Constructor.

        */

        CActiveCmd(

            CLcVtCmdExecutor& aDialog,

            MVtEngCommandHandler& aCommandHandler,

            TVtEngCommandId aCommand,

            TDesC8* aParams );

        /**

        * Destructor.

        */

        ~CActiveCmd();

    public: // New functions

        /**

        * Starts active object. Command will be performed in RunL.

        */

        void Start();

        /**

        * Checks if command has been performed.

        * @return ETrue if command has been performed.

        */

        TBool CommandPerformed() const;

    private:

        /**

        * @see CActive::RunL

        */

        void RunL();

        /**

        * @see CActive::DoCancel.

        */

        void DoCancel();

        /**

        * @see CActive::RunError.

        */

        TInt RunError( TInt aResult );

    private:

        // Ref to dialog.

        CLcVtCmdExecutor& iExecutor;

        // Ref to command handler.

        MVtEngCommandHandler& iCommandHandler;

        // Command to be executed.

        TVtEngCommandId iCommand;

        // Owned parameters.

        TDesC8* iCommandParams;

        // ETrue if command has been performed.

        TBool iCommandPerformed;

    };

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

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

// CLcVtCmdExecutor::CLcVtCmdExecutor

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

//

CLcVtCmdExecutor::CLcVtCmdExecutor(

        CLcVtCmdExecutor** aSelfPtr,

        MVtEngCommandHandler& aCommandHandler,

        MLcVtEngineCommandManager& aCommandManager )

    : iSelfPtr( aSelfPtr ),

      iCommandHandler( aCommandHandler ),

      iCommandManager( aCommandManager )

    {

    iRequest = NULL;

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.Ctor this=%d", (TInt)this )

    }

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

// CLcVtCmdExecutor::~CLcVtCmdExecutor

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

//

CLcVtCmdExecutor::~CLcVtCmdExecutor()

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.~" )

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.~ this=%d", (TInt)this )

    if ( iActiveCmd )

        {

        if ( !iCommandCompleted && iActiveCmd->CommandPerformed() )

            {

            iCommandHandler.CancelCommand( iCommand ); // ignore error

            }

        }

    delete iCommandParams;

    delete iActiveCmd;

    iCommandManager.RemoveObserver( *this );

    if ( iSelfPtr )

        {

        *iSelfPtr = NULL;

        iSelfPtr = NULL;

        }

    if ( iRequest )

        {

        __VTPRINT(DEBUG_GEN, "CLcVtCmdExecutor::~CLcVtCmdExecutor RequestComplete")

        User::RequestComplete( iRequest, KErrCancel );

        iRequest = NULL;

        }

    else

        {

        if ( iWait.IsStarted())

            {

            __VTPRINT(DEBUG_GEN, "CLcVtCmdExecutor::~CLcVtCmdExecutor AsyncStop")

            iWait.AsyncStop();

            }           

        }

    __VTPRINTEXIT( "CLcVtCmdExecutor.~" )

    }

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

// CLcVtCmdExecutor::ExecuteCmdL

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

//

void CLcVtCmdExecutor::ExecuteCmdL(

        const TVtEngCommandId aCommandId,

        TDesC8* aParams,

        TRequestStatus* aRequest )

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.ExecuteCmdL" )

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.ExecuteCmdL this=%d", (TInt)this )

    iCommand = aCommandId;

    CleanupStack::PushL( this );

    if ( aParams )

        {

        iCommandParams = aParams->AllocL();

        }

    iCommandManager.AddObserverL( *this );

    CleanupStack::Pop( this );

    iActiveCmd =

        new ( ELeave ) CActiveCmd(

            *this, iCommandHandler, iCommand, iCommandParams );

    iActiveCmd->Start();    

    if ( !aRequest )

        {

        TInt error = KErrNone;

        iError = &error;

        //Start Active Schedule

        iWait.Start();

        User::LeaveIfError( error );

        }

    else

        {

        *aRequest = KRequestPending;        

        iRequest = aRequest; 

        } 

    __VTPRINTEXIT( "CLcVtCmdExecutor.ExecuteCmdL" )

    }

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

// CLcVtCmdExecutor::Complete

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

//

void CLcVtCmdExecutor::Complete( const TInt aError )

    {

    if ( iError )

        {

        *iError = aError;

        }

    if ( iRequest )

        {

        User::RequestComplete( iRequest, aError );

        iRequest = NULL;

        }

    delete this;

    }

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

// CLcVtCmdExecutor::HandleVTCommandPerformedL

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

//

void CLcVtCmdExecutor::HandleVTCommandPerformedL(

        TVtEngCommandId aCommand,

        const TInt aError )

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.HandleVTCommandPerformed" )

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.HandleVTCommandPerformed.cmd.%d", aCommand )

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.HandleVTCommandPerformed.err.%d", aError )

    if ( iActiveCmd && ( aCommand == iCommand ) )

        {

        if ( iActiveCmd->CommandPerformed() && !iCommandCompleted )

            {

            __VTPRINT( DEBUG_GEN, "CLcVtCmdExecutor.match" )

            iCommandCompleted = ETrue;

            // Corrupted images may leave during initialization, thus we have

            // to mask out errors when they happen during share initialize.

            // Error code is handled correctly in CVtUiAppUi::CEventObserver::

            // HandleVTCommandPerformedL() method, thus it will not be ignored.

            if ( aCommand == KVtEngInitializeShareImage )

                {

                Complete( KErrNone );

                }

            else

                {

                Complete( aError );

                }

            }

        }

    __VTPRINTEXIT( "CLcVtCmdExecutor.HandleVTCommandPerformed" )

    }

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

// CLcVtCmdExecutor::HandleExecuteFailed

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

//

void CLcVtCmdExecutor::HandleExecuteFailed( TInt aResult )

    {

    __VTPRINT3( DEBUG_GEN, "CLcVtCmdExecutor.Fail this=%d res=%d",

        (TInt)this, aResult )

    Complete( aResult );

    }

// Implementation of CLcVtCmdExecutor::CActiveCmd:

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

// CLcVtCmdExecutor::CActiveCmd::CActiveCmd

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

//

CLcVtCmdExecutor::CActiveCmd::CActiveCmd(

        CLcVtCmdExecutor& aExecutor,

        MVtEngCommandHandler& aCommandHandler,

        TVtEngCommandId aCommand,

        TDesC8* aParams)

    : CActive( CActive::EPriorityHigh ),

      iExecutor( aExecutor ),

      iCommandHandler( aCommandHandler ),

      iCommand( aCommand ),

      iCommandParams( aParams )

    {

    CActiveScheduler::Add( this );

    }

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

// CLcVtCmdExecutor::CActiveCmd::~CActiveCmd

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

//

CLcVtCmdExecutor::CActiveCmd::~CActiveCmd()

    {

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.CActiveCmd.Dtor this=%d", (TInt)this )

    Cancel();

    }

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

// CLcVtCmdExecutor::CActiveCmd::Start

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

//

void CLcVtCmdExecutor::CActiveCmd::Start()

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.CActiveCmd.Start" )

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    __VTPRINTEXITR( "CLcVtCmdExecutor.CActiveCmd.Start this=%d", (TInt)this )

    }

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

// CLcVtCmdExecutor::CActiveCmd::CommandPerformed

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

//

TBool CLcVtCmdExecutor::CActiveCmd::CommandPerformed() const

    {

    __VTPRINT3( DEBUG_GEN, "CLcVtCmdExecutor.CActiveCmd.Perf this=%d,cmd=%d",

        (TInt)this, iCommandPerformed )

    return iCommandPerformed;

    }

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

// CLcVtCmdExecutor::CActiveCmd::RunL

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

//

void CLcVtCmdExecutor::CActiveCmd::RunL()

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.CActiveCmd.RunL" )

    iCommandHandler.ExecuteL( iCommand, iCommandParams );

    iCommandPerformed = ETrue;

    __VTPRINTEXITR( "CLcVtCmdExecutor.CActiveCmd.RunL this=%d", (TInt)this )

    }

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

// CLcVtCmdExecutor::CActiveCmd::DoCancel

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

//

void CLcVtCmdExecutor::CActiveCmd::DoCancel()

    {

    __VTPRINT2( DEBUG_GEN, "CLcVtCmdExecutor.CActiveCmd.DoCnl this=%d", (TInt)this )

    // Request is completed immediately.

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::RunError

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

//

TInt CLcVtCmdExecutor::CActiveCmd::RunError( TInt aResult )

    {

    __VTPRINTENTER( "CLcVtCmdExecutor.CActiveCmd.RunError" )

    // Exception was raised in RunL. Inform the dialog to close itself.

    iExecutor.HandleExecuteFailed( aResult );

    __VTPRINTEXITR( "CLcVtCmdExecutor.CActiveCmd.RunError this=%d", (TInt)this )

    return KErrNone;

    }

//  End of File