/*

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

* Implements an AsyncRequest object for the SIF Transport library

*

*/

#include <e32base.h>

#include <e32std.h>

#include <apgcli.h>

#include <scs/ipcstream.h>

#include <scs/nullstream.h>

#include <scs/cleanuputils.h>

#include <usif/usiferror.h>

#include "usiflog.h"

#include "siftransportserver.h"

#include "siftransportcommon.h"

using namespace Usif;

void CSifTransportRequest::CreateAndExecuteL(TInt aFunction, CSifTransportSession* aSession, TransportTaskFactory::GenerateTask aTaskFactory, const RMessage2& aMessage)

	{

	DEBUG_PRINTF2(_L8("CSifTransportRequest::CreateAndExecuteL for aFunction = %d\n"),aFunction);

	CSifTransportRequest* self = new (ELeave) CSifTransportRequest(aFunction, aSession, aMessage);

	CleanupStack::PushL(self);

	// Validate the file handle adoption.

	TInt err = self->AdoptFileHandle(aFunction, aMessage);

	if (err != KErrNone)

		{

		DEBUG_PRINTF2(_L8("Failed to adopt a file handle from RMessage2, error = %d\n"),err);

		aMessage.Panic(KSifTransportServerRequestError, err);

		User::Leave(err);

		}

	self->PrepareParamsL();

	self->SetupRequestL(aTaskFactory);

	self->TransferToScsFrameworkL();

	CleanupStack::Pop(self);

	self->SetActive();

	self->LaunchTask();

	}

// Read file handle from aMessage for all request by file handle.

TInt CSifTransportRequest::AdoptFileHandle(TInt aFunction, const RMessage2& aMessage)

	{	

	if (aFunction & EFileHandleInIpc)

		{

		 return (iFile.AdoptFromClient(aMessage, 0, 1));

		}

	return KErrNone;

	}

CSifTransportRequest::CSifTransportRequest(TInt aFunction, CSifTransportSession* aSession, const RMessage2& aMessage)

	:	CAsyncRequest(aSession, 0, aMessage), iFunction(aFunction), iSecurityContext(aMessage)

	// iFile and iSecurityContext above cannot be a local variable because we pass it to SIF plug-ins during asynchronous calls.

	// Hence, their lifetime must be guaranteed.

	{

	if (iFunction & EInstall)

		{

		iComponentId = EInvalidComponentId;

		}

	// Read component id from aMessage.

	if (aFunction & EComponentIdInIpc)

		{

		iComponentId = aMessage.Int0();

		}

	}

CSifTransportRequest::~CSifTransportRequest()

	{

	DEBUG_PRINTF2(_L8("CSifRequest::~CSifRequest() for aFunction = %d\n"),iFunction);

	Cancel();

	if (iParams.iFileHandle != NULL)

		{

		iParams.iFileHandle->Close();

		}

	delete iParams.iFileName;

	delete iParams.iComponentInfo;

	delete iParams.iCustomArguments;

	delete iParams.iCustomResults;

	delete iTask;

	}

void CSifTransportRequest::PrepareParamsL()

	{

	DEBUG_PRINTF2(_L8("CSifRequest::PrepareParamsL() for aFunction = %d\n"),iFunction);

	// Make sure that the buffers for opaque containers are not allocated

	ASSERT(iParams.iComponentInfo == NULL);

	ASSERT(iParams.iCustomArguments == NULL);

	ASSERT(iParams.iCustomResults == NULL);

	// Read file name from iMessagePtr2

	if (iFunction & EFileNameInIpc)

		{

		// iFileName below cannot be a local variable because we pass it to installation

		// requests during asynchronous calls. Hence, the lifetime of it must be guaranteed.

		HBufC* fileName = HBufC::NewL(KMaxFileName);

		iParams.iFileName = fileName;

		TPtr bufFileName(fileName->Des());

		iMessagePtr2.ReadL(0, bufFileName);

		}

	// Create component info

	if (iFunction & EComponentInfoInIpc)

		{

		iParams.iComponentInfo = CComponentInfo::NewL();

		}

	// Create containers for custom params

	if (iFunction & EOpaqueDataToPlugin)

		{

		// We have to also create these containers for asynchronous requests

		// without opaque params. This is because a request API may not

		// provide methods without opaque params in order to keep it small.

		iParams.iCustomArguments = COpaqueNamedParams::NewL();

		iParams.iCustomResults = COpaqueNamedParams::NewL();

		}

	// Read custom arguments from iMessagePtr2

	if ((iFunction & EOpaqueDataInIpc) && (iFunction & EOpaqueDataToPlugin))

		{

		RIpcReadStream ipcrstream;

		ipcrstream.Open(iMessagePtr2, 2);

		CleanupClosePushL(ipcrstream);

		ipcrstream >> const_cast<COpaqueNamedParams&>(*iParams.iCustomArguments);

		CleanupStack::PopAndDestroy(&ipcrstream);

		}

	}

void CSifTransportRequest::SetupRequestL(TransportTaskFactory::GenerateTask aTaskFactory)

	{

	DEBUG_PRINTF2(_L8("CSifTransportRequest::SetupInstallerRequestL() for aFunction = %d\n"),iFunction);

	iParams.iSecurityContext = &iSecurityContext;

	iParams.iRequestStatus = &iStatus;

	// Instantiate an appropriate SIF Transport Task using aTaskFactory

	switch (iFunction)

		{

		case EGetComponentInfoByFileName:

		case EGetComponentInfoByFileHandle:

			{

			if (iParams.iFileName == NULL)

				{

				iParams.iFileHandle = &iFile;

				}

			iTask = aTaskFactory(TransportTaskFactory::EGetComponentInfo, iParams);

			break;

			}

		case EInstallByFileName:

		case EInstallByFileHandle:

		case EInstallByFileNameWithOpaqueData:

		case EInstallByFileHandleWithOpaqueData:

			{

			if (iParams.iFileName == NULL)

				{

				iParams.iFileHandle = &iFile;

				}

			iTask = aTaskFactory(TransportTaskFactory::EInstall, iParams);

			break;

			}

		case EUninstall:

		case EUninstallWithOpaqueData:

			{

			iParams.iComponentId = iComponentId;

			iTask = aTaskFactory(TransportTaskFactory::EUninstall, iParams);

			break;

			}

		case EActivate:

			{

			iParams.iComponentId = iComponentId;

			iTask = aTaskFactory(TransportTaskFactory::EActivate, iParams);

			break;

			}

		case EDeactivate:

			{

			iParams.iComponentId = iComponentId;

			iTask = aTaskFactory(TransportTaskFactory::EDeactivate, iParams);

			break;

			}

		default:

			ASSERT(0);

		}

	}

void CSifTransportRequest::DoCancel()

	{

	DEBUG_PRINTF2(_L8("CSifTransportRequest::DoCancel() for aFunction = %d\n"),iFunction);

	ASSERT(iTask != NULL);

	iTask->Cancel();

	}

void CSifTransportRequest::DoCleanup()

	{

	DEBUG_PRINTF2(_L8("CSifTransportRequest::DoCleanup() for aFunction = %d\n"),iFunction);

	Cancel();

	}

void CSifTransportRequest::ProcessOpaqueResultsL()

	{

	// Write custom results to iMessagePtr2

	RIpcWriteStream ipcwstream;

	ipcwstream.Open(iMessagePtr2, 3);

	CleanupClosePushL(ipcwstream);

	ipcwstream << *iParams.iCustomResults;

	CleanupStack::PopAndDestroy(&ipcwstream);

	}

void CSifTransportRequest::ProcessTaskResultsL()

	{

	if (iFunction & EComponentInfoInIpc)

		{

		// Write component info to iMessagePtr2

		RIpcWriteStream ipcwstream;

		ipcwstream.Open(iMessagePtr2, 2);

		CleanupClosePushL(ipcwstream);

		ipcwstream << *iParams.iComponentInfo;

		CleanupStack::PopAndDestroy(&ipcwstream);

		}

	if (iFunction & EOpaqueDataInIpc)

		{

		TRAPD(err, ProcessOpaqueResultsL());

		if (err != KErrNone)

			{

			DEBUG_PRINTF3(_L8("CSifRequest::RunL() for aFunction = %d - received error %d while processing opaque results. The error is ignored, since the install operation has already completed"),iFunction, err);

			}

		}

	}

void CSifTransportRequest::RunL()

	{

	DEBUG_PRINTF2(_L8("CSifTransportRequest::RunL() for aFunction = %d\n"),iFunction);

	if (iTaskComplete)

		{

		ProcessTaskResultsL();

		CAsyncRequest::RunL();

		}

	else

		{

		SetActive();

		iTaskComplete = iTask->Execute();

		}

	}

void CSifTransportRequest::LaunchTask()

	{

	iTaskComplete = iTask->Execute();

	}