/*

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

*

*/

#include "mcsdef.h"

#include "mcsmenu.h"

#include "mcsmenufilter.h"

#include "mcsexecuteaction.h"

#include "mcsservice.h"

#include "mcsconstants.h"

#include "mcsmenuopwatcher.h"

#include "mcsoperationmanager.h"

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

// two-phased constructor

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

CMCSExecuteAction* CMCSExecuteAction::NewL( RMenu& aMCS, MMCSCallback* aCallback,

                                    RMcsOperationManager& aOperationManager )

	{

	CMCSExecuteAction* self = new (ELeave) CMCSExecuteAction( aMCS, aCallback, 

	                                                        aOperationManager );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// destructor

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

CMCSExecuteAction::~CMCSExecuteAction()

	{

    Cancel();

	}

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

// default constructor

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

CMCSExecuteAction::CMCSExecuteAction( RMenu& aMCS, MMCSCallback* aCallback,  

                                   RMcsOperationManager& aOperationManager ) :

						CActive( EPriorityStandard ),

						iCallback( aCallback ),

						iMCS( aMCS ),

    					iOperationManager(aOperationManager)						

	{

	}

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

// second phase constructor

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

void CMCSExecuteAction::ConstructL()

	{

	}

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

// ExecuteActionL - Async 

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

void CMCSExecuteAction::ExecuteActionL( TInt aItemId, TDesC8& aAction)

    {

    if( !iCallback )

        {

        User::Leave( KErrArgument );

        }

    iItemId = aItemId;

    iAction.Set(aAction);

    CActiveScheduler::Add ( this );

    ActivateRequest( KErrNone );

    }

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

// ExecuteL - Sync

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

void CMCSExecuteAction::ExecuteL(TInt aItemId, TDesC8& aAction )

    {

    CMenuItem* item = CMenuItem::OpenL( iMCS, aItemId );

	CleanupStack::PushL( item );

	CMCSMenuOpWatcher* watcherAO =  CMCSMenuOpWatcher::NewL( *this, 

	                                                    iOperationManager );

	CleanupStack::PushL( watcherAO );

	iOperationManager.AddL( watcherAO );

    CleanupStack::Pop( watcherAO );// we pop item from cleanupstack because

                                  //ownership was transfered to operation manager

	CMenuOperation* operation = item->HandleCommandL( aAction, 

	                                    KNullDesC8, watcherAO->iStatus);

	watcherAO->Watch( *operation );

	CleanupStack::PopAndDestroy( item );

    }

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

// Inherited from CActive class 

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

//

void CMCSExecuteAction::DoCancel()

	{

//	TRequestStatus* temp = &iStatus;

//	User::RequestComplete( temp, KErrCancel );

	TRAP_IGNORE( iCallback->NotifyResultL( KErrCancel, NULL ));

//	NotifyRequestResult( err );

	}

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

// Inherited from CActive class 

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

//

void CMCSExecuteAction::RunL()

	{

	TInt err = iStatus.Int();

    if ( err == KErrNone )

        {

	}

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

// CMCSExecuteAction::RunError

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

//

TInt CMCSExecuteAction::RunError(TInt aError)

	{

    NotifyRequestResult( aError );

	return aError; 

	}

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

// Activates the asynchronous request

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

//

void CMCSExecuteAction::ActivateRequest( TInt aReason )

	{

	iStatus = KRequestPending;

	SetActive();

	TRequestStatus* temp = &iStatus;

    User::RequestComplete( temp, aReason );

	}

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

// Notifies callback the result for asynchronous request.

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

//

void CMCSExecuteAction::NotifyRequestResult( TInt aReason )

    {

    iOperationManager.Remove( this );//remove it 

       								//from operation manager  

    if ( iCallback )

        {

        TRAP_IGNORE( iCallback->NotifyResultL( aReason) ); 

        // iCallback deletes itself.

        }

    delete this;

    }

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

// Notifies callback the result for asynchronous request.

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

//

void CMCSExecuteAction::MenuOpCompletedL(TInt aStatus )

	{

	NotifyRequestResult( aStatus );

	}