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

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	{

	InternalCancelHandler(CUissClientHandler& aUissClientHandler);

	void HandleCancel();

	CUissClientHandler& iUissClientHandler;

	};

	CUissClientHandler& aUissClientHandler)

:	iUissClientHandler(aUissClientHandler)

	{

	}

	{

	iUissClientHandler.CancelOperation();

	}

	{

	CUissClientHandler* self=new(ELeave) CUissClientHandler(aUiHandler, aActiveObjectMode);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

	{

	CUissClientHandler* self=NewLC(aUiHandler, aActiveObjectMode);

	CleanupStack::Pop(self);

	return self;

	}

		  iPtrIntoBuf(0,0),

		  iPtrIntoArgsStream(0,0)

		  #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

		  ,iCompInfoBufPtr(0,0)

		  #endif

	{

		{

		CActiveScheduler::Add(this);

		}

	}

	{	

	if(iSisHelper.Handle() > 0)

		{

		TRequestStatus reqStatus;

		iSisHelper.Logon(reqStatus);

		User::WaitForRequest(reqStatus);

		iSisHelper.Close();

		}		

	}

	{

	//Cancel any outstanding request

	CancelOperation();

	WaitForSisHelperShutdown();

		{

		CActive::Cancel(); // Make sure we are cancelled before deletion

		}

	delete iCancelHandler;

	iUissSession.Close();

	delete iBuf;

	#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

	#endif

	}

	{

	iCancelHandler=new(ELeave) InternalCancelHandler(*this);

	AllocBufL(KBufSize);// Allocate the initial r/c buffer

	User::LeaveIfError(StartUiss()); // Start UISS

	User::LeaveIfError(iUissSession.Connect()); // Connect to UISS

	}

	{

	{

	// Reallocate the buffer to the size received in parameter 1

	TInt size=0;

	TPckg<TInt> theSize(size);

	theSize.Copy(iBuf->Left(sizeof(TInt)));

	AllocBufL(size);

	}

	{

	{

	switch (aCommand)

		{

		case CUissSession::KMessageApplicationsInUseDialog:

			return new(ELeave) CApplicationsInUseDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageCannotOverwriteFileDialog:

			return new(ELeave) CCannotOverwriteFileDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageDependencyBreakDialog:

			return new(ELeave) CDependencyBreakDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageDeviceIncompatibility:

			return new(ELeave) CDeviceIncompatibilityDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageMissingDependency:

			return new(ELeave) CMissingDependencyDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageDriveDialog:

			return new(ELeave) CDriveDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageErrorDialog:

			return new(ELeave) CErrorDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageGrantCapabilitiesDialog:

			return new(ELeave) CGrantCapabilitiesDialogCmdHandler(iUiHandler);	

		case CUissSession::KMessageHandleCancellableInstallEvent:

			return new(ELeave) CHandleCancellableInstallEventCmdHandler(iUiHandler, 

				*iCancelHandler);

		case CUissSession::KMessageHandleInstallEvent:

			return new(ELeave) CHandleInstallEventCmdHandler(iUiHandler);

		case CUissSession::KMessageInstallDialog:

			return new(ELeave) CInstallDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageLanguageDialog:

			return new(ELeave) CLanguageDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageOcspResultDialog:

			return new(ELeave) COcspResultDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageOptionsDialog:

			return new(ELeave) COptionsDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageQuestionDialog:

			return new(ELeave) CQuestionDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageSecurityWarningDialog:

			return new(ELeave) CSecurityWarningDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageUninstallDialog:

			return new(ELeave) CUninstallDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageUpgradeDialog:

			return new(ELeave) CUpgradeDialogCmdHandler(iUiHandler);

		case CUissSession::KMessageTextDialog:

			return new(ELeave) CTextDialogCmdHandler(iUiHandler);

		default:

			return NULL;

		}

	}

	{

	// Stream out install parameters. Cannot do this in UISSCLIENT because 

	// the code is in LAUNCHER which depends on UISSCLIENT.

	iArgsStream = CWriteStream::NewL();

	*iArgsStream << aInstallPrefs;

	iPtrIntoArgsStream.Set(iArgsStream->Ptr());	

	}

	{

	iPtrIntoBuf.Set(iBuf->Des());

	InitializeArgStreamL(aInstallPrefs);

	iArgsStream->Stream().WriteInt32L(aDeviceSupportedLanguages.Count());

	//Streaming set of languages that device supports

	TInt noOfDeviceSupportedLanguages = aDeviceSupportedLanguages.Count();

	for(TInt i=0;i<noOfDeviceSupportedLanguages;i++)

		{

		iArgsStream->Stream().WriteInt32L(aDeviceSupportedLanguages[i]);

		}

	// Save ptr for args (must persist whilst server is processing)

	iPtrIntoArgsStream.Set(iArgsStream->Ptr());	

		{

		SetActive();

		}

	}

	{	

	InitializeArgStreamL(aInstallPrefs);

	AllocCompInfoBufL(KCompInfoBufferSize);	

	// Save the pointer for component info collection buffer

	iCompInfoBufPtr.Set(iCompInfoBuffer->Des());

	// There is no synchronous API for GetComponentInfo

	__ASSERT_ALWAYS(iActiveObjectMode, User::Invariant());

	SetActive();

    iSisHelper = aServer;	

	}

	{

	iArgsStream = CWriteStream::NewL();

	iPtrIntoArgsStream.Set(iArgsStream->Ptr());

	// Issue initial request

		{

		SetActive();

		}

	}

	{

	if (iState == KUissClientIdle)

		{

		return;

		}

	// User called this so must have an outstanding request with us.

	// First tell the Uiss that we want to cancel the current

	// operation.

	//

	// If we have an outstanding Uiss request, this will complete (with

	// KErrCancel) when the operation has terminated.

	//

	// If we are called inside a dialog callback, then there is no

	// outstanding Uiss request at the moment. When the dialog

	// returns, we will issue a request, which will complete (with

	// KErrCancel) when the operation has terminated.

	(void)iUissSession.Cancel();

	}

	{

	// Keep processing UISS responses and issuing new requests

	// until we update the client status to non-pending.

	while(iClientStatus && *iClientStatus == KRequestPending) 

		{

		User::WaitForRequest(iStatus);

		TRAPD(err,RunL());

		if(err != KErrNone)

			{	

			RunError(err);

			}

		}

	}

	{

	return iState != KUissClientIdle;

	}

	{

	const TInt KUissServerStackSize=0x2000;

	const TInt KUissServerInitHeapSize=0x1000;

	const TInt KUissServerMaxHeapSize=0x1000000;

	TThreadFunction entryPoint=UissThreadFunction;

	//TUiSupportStartParams uiSupportParams(aUiHandler);

	// The owner of the new thread will be the process, otherwise if the 

	// current thread dies, the server thread will die, too.

	RThread server;

	TInt err = KErrNone;

	for (TInt retry=0; retry < 2; ++retry)

		{

		err = server.Create(KUissServerName, entryPoint, 

		KUissServerStackSize, KUissServerInitHeapSize, KUissServerMaxHeapSize,

		NULL, EOwnerThread);

		if (err == KErrAlreadyExists)

			{

			User::After(30000);	

			}

		else

			{

			break;

			}

		}

	if (err==KErrAlreadyExists)

		{

		return KErrServerBusy;

		}

	if (err != KErrNone)

		{

		return err;

		}

	// Synchronise with the process to make sure it hasn't died straight away

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat != KRequestPending)

		{

		// logon failed - server is not yet running, so cannot have terminated

		server.Kill(0); // Abort startup

		}

	else

		{

		// logon OK - start the server

		server.Resume();

		}

	// Wait to synchronise with server - if it dies in the meantime, it

	// also gets completed

	User::WaitForRequest(stat);	

	// We can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	TInt r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

	server.Close();

	return r;

	}

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

	CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(scheduler);

	CUissServer* server=NULL;

	TRAPD(err, server=CUissServer::NewL());

	if (err==KErrNone)

		{

		RThread::Rendezvous(KErrNone);

		scheduler->Start();

		}

	delete server;

	CActiveScheduler::Install(NULL);

	delete scheduler;

	delete cleanup; // destroy clean-up stack

	__UHEAP_MARKEND;

	return KErrNone;

	}

	iPtrIntoBuf.Set(iBuf->Des()); // Get ptr to our return buffer

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK	

		&& iState != KUissClientGettingCompInfo // We don't support overflow management for component info

		)

		iUissSession.BufferReallocated(iPtrIntoBuf, iStatus);

		if (iActiveObjectMode)

			{

			SetActive();

			}

		return;

		}

	else

		{

		if (err>CUissSession::KMsgSeparatorMinimumSwisMessage && 

			err<CUissSession::KMsgSeparatorMaximumSwisMessage)