/*

* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Base class functionality for server-side asynchronous requests.

*

*/

/**

 @file

*/

#include <scs/scsserver.h>

#include "scsserverconstants.h"

EXPORT_C CAsyncRequest::CAsyncRequest(CScsSession* aSession, CScsSubsession* aSubsession, const RMessage2& aMessage)

/**

	Record the session, subsession, and function associated with this request.

	These are required to complete or to cancel the request later.

	Adds this object to the active scheduler.

	@param	aSession		Session used to launch this request.

	@param	aSubsession		Subsession on which this request is queued.  This

							should be NULL if the request is relative to a session,

							instead of a subsession

	@param	aMessage		Handle to the kernel-side request object, which

							will be completed later.

 */

:	CActive(CActive::EPriorityStandard),

	iSession(aSession),

	iSubsession(aSubsession),

	iMessagePtr2(aMessage)

	{

	// extract implementation function

	ScsImpl::ExtractScsAndImplFunctions(aMessage, NULL, &iFunction);

	CActiveScheduler::Add(this);

	}

EXPORT_C void CAsyncRequest::TransferToScsFrameworkL()

/**

	Adds this asynchronous request to the global collection.

	This should be called after the subclass has performed its

	own initialization, but before the active request has been

	set up.

 */

	{

	iSession->iServer.AddAsyncRequestL(this);

	}

EXPORT_C void CAsyncRequest::RunL()

/**

	Implement CActive by completing the server client's request status

	with the AO error code, i.e. iStatus.  This function also marks this

	object for deletion.

	If a subclass overrides this implementation then it must call

	CompleteAndMarkForDeletion itself to complete the client-side

	request.

	@see CompleteAndMarkForDeletion

 */

	{

	TInt r = iStatus.Int();

	CompleteAndMarkForDeletion(r);

	}

EXPORT_C TInt CAsyncRequest::RunError(TInt aError)

/**

	Override CActive by completing the request with the

	supplied error code and marking this object for deletion.

	The default implementation of RunL cannot leave, but the

	subclass may override it with a more complex implementation.

	@param	aError			Error code with which aError left.

	@return					KErrNone, meaning do not propagate

							the error to the active scheduler.

 */

	{

	CompleteAndMarkForDeletion(aError);

	return KErrNone;

	}

void CAsyncRequest::CancelCompleteAndMarkForDeletion()

/**

	Cancel this asynchronous request and complete the client

	request with KErrCancel.  On exit, this object has been

	marked for deletion.

 */

	{

	CompleteAndMarkForDeletion(KErrCancel);

	}

EXPORT_C void CAsyncRequest::CompleteAndMarkForDeletion(TInt aError)

/**

	Completes the client-side request associated with this

	asynchronous request and marks this object for deletion.

	If the error was because the client passed a bad descriptor then

	panick the client instead of completing the request for consistency

	with synchronous requests.

	@param	aError			Error code with which the client request

							will be completed.

 */

	{

	if (aError == KErrBadDescriptor)

		PanicClient(iMessagePtr2, ScsImpl::EScsClBadDesc);

	else

		iMessagePtr2.Complete(aError);

	MarkForDeletion();

	}

void CAsyncRequest::MarkForDeletion()

/**

	Mark this outstanding request for deletion, so it is

	cleaned up when the cleanup AO runs.

 */

	{

	DoCleanup();

	// The deletion is processed at priority CActive::EPriorityHigh,

	// so should happen ahead of any pending or new requests.

	CAsyncCallBack* acb = iSession->iServer.iAsyncCleanup;

	acb->CallBack();		// no effect if already queued

	iSession = NULL;		// mark for deletion		

	}

EXPORT_C void CAsyncRequest::DoCleanup()

/**

	This virtual function is called whenever the SCS needs to cancel an operation.

	If the asynchronous request implementation ALWAYS has an internal request active

	for the duration of the client request, then this default implementation can be used, which

	simply calls  CActive::Cancel which will call the derived classe's DoCancel (if, and only if

	the object IsActive).

	A more complex case is where the asynchronous requests may enter an internal queue where

	the client request is (obviously still active), but the derived class has not outstanding request.

	In this case the default implementation will cause a HANG, because Cancel will not call DoCancel if

	the object is not active...

	In the generic case, the derived class should provide an overload for the Cleanup method.

	This function should call Cancel to cancel any outstanding operation, then perform whatever other

	cleanup is required to cleanup the request (closing handles, removing from queues etc).

	The framework will then complete the client request.

	 nb. The destructor of the CAsyncRequest may not run until sometime after the client request has been

	 completed.

 */

{

	Cancel();

}