/*

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

* CAsyncResponseDecoder - Auth Client helper class

*

*/

/**

 @file 

*/

#include <e32debug.h>

#include <s32mem.h>

#include "authclient_impl.h"

using namespace AuthServer;

namespace AuthServer

{

HBufC8* ExternalizeExpressionL(const CAuthExpression* aExpr);

enum {  EPanicBadCmd = 1 };

_LIT(KAsyncDecoderBusy, "AuthClient busy");

}

CAsyncResponseDecoder::CAsyncResponseDecoder(const RAuthClient& aSession) :

	CActive(EPriorityStandard), iSession(aSession), 

	iBufDes(0,0), iParamsPtr(0,0)

    {

	CActiveScheduler::Add(this);

	}

CAsyncResponseDecoder::~CAsyncResponseDecoder()

    {

    Cleanup();

    }

void CAsyncResponseDecoder::AuthenticateL(

						   const CAuthExpression& aExpression,

						   TTimeIntervalSeconds   aTimeout,

						   TBool                  aClientSpecificKey,

						   TUid 				  aClientSid,

						   TBool                  aWithString,

						   const TDesC& 		  aClientMessage,

						   CIdentity*&            aIdentityResult, 

						   TRequestStatus&        aClientStatus)

	{

	__ASSERT_ALWAYS(!IsActive(), User::Panic(AuthServer::KAsyncDecoderBusy, 0));

	iExpression       	     = &aExpression;

	iResult            	     = &aIdentityResult;

	iClientStatus            = &aClientStatus;

	//Create a flat buffer.

  	CBufFlat* flatBuffer = CBufFlat::NewL(KDefaultBufferSize);

  	CleanupStack::PushL(flatBuffer);

  	//Initialize the CAuthParams object.

  	CAuthParams* params = CAuthParams::NewL(aTimeout,

  											aClientSpecificKey,

											aClientSid,

  											aWithString,

  											aClientMessage);

  	CleanupStack::PushL(params);

  	//Externalize params.

  	RBufWriteStream stream(*flatBuffer);

  	CleanupClosePushL(stream);

  	params->ExternalizeL(stream);

  	CleanupStack::PopAndDestroy(2, params);

  	iParamsBuffer = HBufC8::NewL(flatBuffer->Size());

  	iParamsPtr.Set(iParamsBuffer->Des());

  	flatBuffer->Read(0, iParamsPtr, flatBuffer->Size());

  	CleanupStack::PopAndDestroy(flatBuffer);

	//Externalize the expression.

  	iExprBuf = ExternalizeExpressionL(iExpression);

	// allocate buffer for identity result.

	iBuffer = HBufC8::NewL(KDefaultBufferSize);

	iBufDes.Set(iBuffer->Des());

	iArgs = new (ELeave)TIpcArgs(iExprBuf,

								 &iParamsPtr,

								 &iBufDes); 

	StartCall(EAuthenticate);

	}

void CAsyncResponseDecoder::RegisterIdentityL(CIdentity*& aIdentity,

											 const TDesC& aDescription,  

											 TRequestStatus& aClientStatus)

	{

	__ASSERT_ALWAYS(!IsActive(), User::Panic(KAsyncDecoderBusy, 0));

	iBuffer = HBufC8::NewL(KDefaultBufferSize);

	iBufDes.Set(iBuffer->Des());

	iResult = &aIdentity;

	iDescription = HBufC::NewL(aDescription.Size());

	*iDescription = aDescription;

	iClientStatus = &aClientStatus;

	iArgs = new (ELeave)TIpcArgs(&iBufDes, iDescription);

	StartCall(ERegisterIdentity);

	}

void CAsyncResponseDecoder::StartCall(TAuthServerMessages aCmd)

	{

	iCmd = aCmd;

	iStatus = KRequestPending;

	*iClientStatus = KRequestPending;

	SetActive();

	iSession.CallSessionFunction(iCmd, *iArgs, iStatus);

	}

void CAsyncResponseDecoder::RunL() 

	{

	if (iStatus.Int() == KErrNone)

		{

		RDesReadStream readStream(*iBuffer);

		switch (iCmd)

			{

			case EAuthenticate:

				*iResult = CIdentity::InternalizeL(readStream);

				break;

			case ERegisterIdentity:

				*iResult = CIdentity::InternalizeL(readStream);

				break;

			default:

				User::Panic(_L("AuthClient-AsyncResponseDecoder"),

							EPanicBadCmd);

			}

		}

	User::RequestComplete(iClientStatus,iStatus.Int());

	Cleanup();

	}

TInt CAsyncResponseDecoder::RunError(TInt aError)

	{	

	User::RequestComplete(iClientStatus, aError);

	Cleanup();    			

	return KErrNone;

	}

void CAsyncResponseDecoder::DoCancel()

	{

	switch (iCmd)

		{

		case EAuthenticate:

		case ERegisterIdentity:

			User::RequestComplete(iClientStatus, KErrCancel);

			break;

		default:

		    break;

		}

	Cleanup();

    }

void CAsyncResponseDecoder::Cleanup()

    {

	delete iArgs;

	iArgs = 0;

	delete iExprBuf;

	iExprBuf = 0;

	delete iBuffer;

	iBuffer = 0;

    delete iDescription;

    iDescription = 0;

    delete iParamsBuffer;

    iParamsBuffer = 0;

	iCmd = ELastService;

	iClientStatus = 0;

    }