/*

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

*

*/

// INCLUDE FILES

#include    "CVtUiExecuteCmdDialog.h"

#include    "MVtUiEngineCommandManager.h"

#include    <mvtengcommandhandler.h>

#include    <cvtlogger.h>

// MODULE DATA STRUCTURES

/**

* Active object to perform asynchronous commands.

* @since Series 60 2.6

*/

class CVtUiExecuteCmdDialog::CActiveCmd

    : public CActive

    {

    public: // Constructors and destructor

        /**

        * Constructor.

        */

        CActiveCmd(

            CVtUiExecuteCmdDialog& 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.

        CVtUiExecuteCmdDialog& iDialog;

        // 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 ===============================

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

// CVtUiExecuteCmdDialog::CVtUiExecuteCmdDialog

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

//

CVtUiExecuteCmdDialog::CVtUiExecuteCmdDialog(

        CEikDialog** aSelfPtr,

        MVtEngCommandHandler& aCommandHandler,

        MVtUiEngineCommandManager& aCommandManager )

    : CVtUiBlankDialog( aSelfPtr ),

      iCommandHandler( aCommandHandler ),

      iCommandManager( aCommandManager )

    {

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

    }

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

// CVtUiExecuteCmdDialog::~CVtUiExecuteCmdDialog

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

//

CVtUiExecuteCmdDialog::~CVtUiExecuteCmdDialog()

    {

    __VTPRINTENTER( "VtUiExCmdDlg.~" )

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

    if ( iActiveCmd )

        {

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

            {

            iCommandHandler.CancelCommand( iCommand ); // ignore error

            }

        }

    delete iCommandParams;

    delete iActiveCmd;

    iCommandManager.RemoveObserver( *this );

    __VTPRINTEXIT( "VtUiExCmdDlg.~" )

    }

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

// CVtUiExecuteCmdDialog::ExecuteCmdLD

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

//

void CVtUiExecuteCmdDialog::ExecuteCmdLD(

        const TVtEngCommandId aCommandId,

        TDesC8* aParams,

        TRequestStatus* aRequest )

    {

    __VTPRINTENTER( "VtUiExCmdDlg.ExecuteCmd" )

    __VTPRINT2( DEBUG_GEN, "Ui.Dlg.Exec this=%d", (TInt)this )

    iCommand = aCommandId;

    CleanupStack::PushL( this );

    if ( aParams )

        {

        iCommandParams = aParams->AllocL();

        }

    iCommandManager.AddObserverL( *this );

    CleanupStack::Pop( this );

    CVtUiBlankDialog::ExecuteDialogLD( aRequest );

    __VTPRINTEXIT( "VtUiExCmdDlg.ExecuteCmd" )

    }

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

// CVtUiExecuteCmdDialog::PostLayoutDynInitL

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

//

void CVtUiExecuteCmdDialog::PostLayoutDynInitL()

    {

    __VTPRINTENTER( "VtUiExCmdDlg.PostL" )

    iActiveCmd =

        new ( ELeave ) CActiveCmd(

            *this, iCommandHandler, iCommand, iCommandParams );

    iActiveCmd->Start();

    __VTPRINTEXITR( "VtUiExCmdDlg.PostL this=%d", (TInt)this )

    }

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

// CVtUiExecuteCmdDialog::HandleVTCommandPerformedL

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

//

void CVtUiExecuteCmdDialog::HandleVTCommandPerformedL(

        TVtEngCommandId aCommand,

        const TInt aError )

    {

    __VTPRINTENTER( "VtUiExCmdDlg.HandleVTCommandPerformed" )

    __VTPRINT2( DEBUG_GEN, "VtUiExCmdDlg.cmd.%d", aCommand )

    __VTPRINT2( DEBUG_GEN, "VtUiExCmdDlg.err.%d", aError )

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

        {

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

            {

            __VTPRINT( DEBUG_GEN, "VtUiExCmdDlg.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( "VtUiExCmdDlg.HandleVTCommandPerformed" )

    }

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

// CVtUiExecuteCmdDialog::HandleExecuteFailed

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

//

void CVtUiExecuteCmdDialog::HandleExecuteFailed( TInt aResult )

    {

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

        (TInt)this, aResult )

    Complete( aResult );

    }

// Implementation of CVtUiExecuteCmdDialog::CActiveCmd:

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

// CVtUiExecuteCmdDialog::CActiveCmd::CActiveCmd

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

//

CVtUiExecuteCmdDialog::CActiveCmd::CActiveCmd(

        CVtUiExecuteCmdDialog& aDialog,

        MVtEngCommandHandler& aCommandHandler,

        TVtEngCommandId aCommand,

        TDesC8* aParams)

    : CActive( CActive::EPriorityHigh ),

      iDialog( aDialog ),

      iCommandHandler( aCommandHandler ),

      iCommand( aCommand ),

      iCommandParams( aParams )

    {

    CActiveScheduler::Add( this );

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::~CActiveCmd

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

//

CVtUiExecuteCmdDialog::CActiveCmd::~CActiveCmd()

    {

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

    Cancel();

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::Start

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

//

void CVtUiExecuteCmdDialog::CActiveCmd::Start()

    {

    __VTPRINTENTER( "VtUiExCmdDlgCmd.Start" )

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

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

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::CommandPerformed

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

//

TBool CVtUiExecuteCmdDialog::CActiveCmd::CommandPerformed() const

    {

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

        (TInt)this, iCommandPerformed )

    return iCommandPerformed;

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::RunL

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

//

void CVtUiExecuteCmdDialog::CActiveCmd::RunL()

    {

    __VTPRINTENTER( "VtUiExCmdDlgCmd.RunL" )

    iCommandHandler.ExecuteL( iCommand, iCommandParams );

    iCommandPerformed = ETrue;

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

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::DoCancel

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

//

void CVtUiExecuteCmdDialog::CActiveCmd::DoCancel()

    {

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

    // Request is completed immediately.

    }

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

// CVtUiExecuteCmdDialog::CActiveCmd::RunError

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

//

TInt CVtUiExecuteCmdDialog::CActiveCmd::RunError( TInt aResult )

    {

    __VTPRINTENTER( "VtUiExCmdDlgCmd.RunError" )

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

    iDialog.HandleExecuteFailed( aResult );

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

    return KErrNone;

    }

//  End of File