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

	{

	static TDesC* CopyLC(const TDesC& aOther) { return aOther.AllocLC(); }

	static TDesC* ReadFromStreamLC(RReadStream& aStream) { return HBufC::NewLC(aStream, KMaxTInt); }

	static void WriteToStreamL(const TDesC& aItem, RWriteStream& aStream) { aStream << aItem; }

	};

	{

	}

	{

	Server().AddSession();

	}

	{

	Server().DropSession();

	}

	{

	TFileName filename;

	aMessage.ReadL(0, filename);

	TBool wait;

	TPckg <TBool> waitPckg(wait);

	aMessage.ReadL(1, waitPckg);

	Server().RunExecutableL(filename, wait);

	aMessage.Complete(KErrNone);

	}

	{

	TFileName filename;

	aMessage.ReadL(0, filename);

	TBool wait;

	TPckg <TBool> waitPckg(wait);

	aMessage.ReadL(1, waitPckg);

	if (Server().BootUpMode() == KTextShell) 

		{

		// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

		DEBUG_PRINTF2(_L8("Sis Launcher Server - textshell - skipping start document by file handle. wait = %d"), wait);	

		}

	else

		{ 

		// emulatore running with GUI

		#ifndef SWI_TEXTSHELL_ROM

			Server().StartDocumentL(filename, wait);

		#endif

		}

	aMessage.Complete(KErrNone);	

	}

	{

	RFile file;

	file.AdoptFromClient(aMessage, 0, 1);

	CleanupClosePushL(file);

	TBool wait;

	TPckg <TBool> waitPckg(wait);

	aMessage.ReadL(2, waitPckg);

	if (Server().BootUpMode() == KTextShell)

		{

		// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

		DEBUG_PRINTF3(_L8("Sis Launcher Server - textshell - skipping start document %S, wait = %d"),

				&file, wait);

		}

	else

		{

		// emulatore running with GUI

		Server().StartDocumentL(file, wait);

		}

	CleanupStack::PopAndDestroy(&file);

	aMessage.Complete(KErrNone);

	{

	TFileName filename;

	aMessage.ReadL(0, filename);

	TInt srcLen = aMessage.GetDesLengthL(1);

	HBufC8* mimeType = HBufC8::NewLC(srcLen);

	TPtr8 ptr(mimeType->Des());

	aMessage.ReadL(1, ptr);

	TBool wait;

	TPckg <TBool> waitPckg(wait);

	aMessage.ReadL(2, waitPckg);

	if (Server().BootUpMode() == KTextShell) 

		{

		// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

		DEBUG_PRINTF3(_L8("Sis Launcher Server - textshell - skipping start document by file handle mimetype %S, wait = %d"),

				mimeType, wait);	

		}

	else

		{

		// emulatore running with GUI

		Server().StartByMimeL(filename, *mimeType, wait);

		}		

	CleanupStack::PopAndDestroy(mimeType);

	aMessage.Complete(KErrNone);

	}

	{

	RFile file;

	file.AdoptFromClient(aMessage, 0, 1);			

	CleanupClosePushL(file);

	TInt srcLen = aMessage.GetDesLengthL(2);

	HBufC8* mimeType = HBufC8::NewLC(srcLen);

	TPtr8 ptr(mimeType->Des());

	aMessage.ReadL(2, ptr);

	TBool wait;

	TPckg <TBool> waitPckg(wait);

	aMessage.ReadL(3, waitPckg);

	if (Server().BootUpMode() == KTextShell) 

		{

		// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

		DEBUG_PRINTF4(_L("Sis Launcher Server - textshell - skipping launch of document %S, mimetype %s, wait %d"),

				&file, mimeType, wait);

		}

	else

		{

		// emulatore running with GUI

		Server().StartByMimeL(file, *mimeType, wait);

		}		

	CleanupStack::PopAndDestroy(mimeType);

	CleanupStack::PopAndDestroy(&file);

	aMessage.Complete(KErrNone);

	}

	{

	DEBUG_PRINTF2(_L8("Sis Launcher Server - Servicing Message %d"), aMessage.Function());

	switch (aMessage.Function())

		{

		case ERunExecutable:

			DoRunExecutableL(aMessage);

			break;

		case EStartDocument:

			DoStartDocumentL(aMessage);			

			break;

		case EStartDocumentByHandle:

			DoStartDocumentByHandleL(aMessage);

			break;	

		case EStartByMime:

			DoStartByMimeL(aMessage);

			break;

		case EStartByMimeByHandle:

			DoStartByMimeByHandleL(aMessage);

			break;

		case EShutdown:

			{

			TInt srcLen=aMessage.GetDesLengthL(0);

			HBufC8* uidBuffer = HBufC8::NewLC(srcLen);

			TPtr8 uidPtr = uidBuffer->Des();

			aMessage.ReadL(0, uidPtr, 0);

			TUint8* dataPtr=const_cast<TUint8*>(uidPtr.Ptr());

			TUid* tUidPtr=reinterpret_cast<TUid*>(dataPtr);

			TInt8 uidCount=srcLen/sizeof(TUid);

			TInt shutdownTimeout = aMessage.Int1();

			if (Server().BootUpMode() == KTextShell) 

				{

				// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

				DEBUG_PRINTF(_L8("Sis Launcher Server - textshell - skipping graceful shutdown of GUI applications"));

				}

			else

				{

				// emulatore running with GUI

				#ifndef SWI_TEXTSHELL_ROM

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

						{

						// graceful shutdown

						Server().ShutdownL(tUidPtr[i], shutdownTimeout);	

						}

				#endif

				}

			// Having tried graceful shutdown, we need to kill any remaining processes

			// matching the SID.  Note that killing a process may re-order the list of

			// remaining processes, so the search must start from the top again.

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

				{

				Server().ForceShutdownL(tUidPtr[i]);

				}			

			CleanupStack::PopAndDestroy(uidBuffer);

			aMessage.Complete(KErrNone);

			break;

			}

		case EShutdownAll:

			{

			if (Server().BootUpMode() == KTextShell) 

				{

				// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

				DEBUG_PRINTF(_L8("Sis Launcher Server - textshell - skipping shutdown of user applications"));	

				}

			else

				{

				// emulatore running with GUI

				#ifndef SWI_TEXTSHELL_ROM

				Server().ShutdownL();

				#endif

				}

			aMessage.Complete(KErrNone);

			break;	

			}

		case ECheckApplicationInUse:

			{

			TInt srcLen=aMessage.GetDesLengthL(0);

			HBufC8* appInUseBuffer = HBufC8::NewLC(srcLen);

			TPtr8 appInUseBufferPtr = appInUseBuffer->Des();	

			aMessage.ReadL(0, appInUseBufferPtr, 0);

			TAppInUse* appInUsePtr = (TAppInUse*) User::AllocL(srcLen);

			CleanupStack::PushL(appInUsePtr);	

			Mem::Copy(appInUsePtr, appInUseBufferPtr.Ptr(), srcLen);

			TUint appInUseCount=srcLen/sizeof(TAppInUse);

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

				{

				TRAPD(err, CheckApplicationInUseL(appInUsePtr[i].iAppUid));

				if (err==KErrInUse)  

					{

 					appInUsePtr[i].iInUse=ETrue;

					}			 

				}	

			TUint8* dataPtr=reinterpret_cast<TUint8*>(appInUsePtr);

 			const TPtrC8 data(dataPtr, srcLen);	

 			//Indicate the client apps in use

 			aMessage.WriteL(0, data);							

			aMessage.Complete(KErrNone);

			CleanupStack::PopAndDestroy(appInUsePtr);

			CleanupStack::PopAndDestroy(appInUseBuffer); 	

			break;

			}

	    case ENotifyNewApps:

			{

			TInt size = aMessage.GetDesLengthL(0);

			HBufC8* buf = HBufC8::NewLC(size);

			TPtr8 bufPtr = buf->Des();

			aMessage.ReadL(0, bufPtr);

			RDesReadStream stream(*buf);

			RPointerArray<TDesC> files;

			InternalizePointerArrayL(files, stream);

			if (Server().BootUpMode() == KTextShell) 

				{

				// emulator tests running in textshell or in textshell ROM (#def SWI_TEXTSHELL_ROM)

				DEBUG_PRINTF(_L8("Sis Launcher Server - textshell - skipping notification of new applications."));

				}

			else

				{

				// emulatore running with GUI

				#ifndef SWI_TEXTSHELL_ROM

				Server().NotifyNewAppsL(files);

				#endif

				}

			files.ResetAndDestroy();

			CleanupStack::PopAndDestroy(buf);

			aMessage.Complete(KErrNone);

			break;

			}

		case EParseSwTypeRegFile:

			#ifndef SWI_TEXTSHELL_ROM

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			ParseSwTypeRegFileL(aMessage);

			#endif

			#endif

			aMessage.Complete(KErrNone);

			break;

		case ERegisterSifLauncherMimeTypes:

			#ifndef SWI_TEXTSHELL_ROM

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			RegisterSifLauncherMimeTypesL(aMessage);

			#endif

			#endif

			aMessage.Complete(KErrNone);

			break;

		case EUnregisterSifLauncherMimeTypes:

			#ifndef SWI_TEXTSHELL_ROM

			#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

			UnregisterSifLauncherMimeTypesL(aMessage);

			#endif

			#endif

			aMessage.Complete(KErrNone);

			break;

	    case EQueueRunExecutable:

	    	//fall through

	    case EQueueStartDocumentByHandle:

	    	//fall through

	    case EQueueStartByMimeByHandle:

	    	Server().RunQueue().AddToQueueL(aMessage);

	    	aMessage.Complete(KErrNone);

	    	break;

	    case EExecuteQueue:

	    	aMessage.Complete(Server().RunQueue().ExecuteQueue());

	    	break;

	    case EKillQueue:

	    	Server().RunQueue().ResetQueue();

	    	aMessage.Complete(KErrNone);

	    	break;

	    default:

			{

			PanicClient(aMessage,EPanicIllegalFunction);

			break;

			}

		}

	}

	{

	DEBUG_PRINTF2(_L8("Sis Launcher Server - ServiceL failed with error code %d."), aError);

	if (aError==KErrBadDescriptor)

		{

		PanicClient(aMessage,EPanicBadDescriptor);

		}

	CSession2::ServiceError(aMessage,aError);

	}

	{

	TFindProcess findProcess;

	TFullName fullName;

	while(findProcess.Next(fullName) == KErrNone)

		{

		RProcess process;

		User::LeaveIfError(process.Open(findProcess));

		TUid sid(process.SecureId());

		TExitType exitType = process.ExitType();

		process.Close();

		if (sid == aUid && exitType == EExitPending)

					User::Leave(KErrInUse);

		}

	}

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

void CSisLauncherSession::ParseSwTypeRegFileL(const RMessage2& aMessage)

	{

	// Unpack the file handle

	RFile file;

	User::LeaveIfError(file.AdoptFromClient(aMessage, 0, 1));

	CleanupClosePushL(file);

	// Read the registration file

	TInt fileSize = 0;

	User::LeaveIfError(file.Size(fileSize));

	HBufC8* buf = HBufC8::NewLC(fileSize);

	TPtr8 bufPtr = buf->Des();

	User::LeaveIfError(file.Read(bufPtr));

	// Parse the registration file

	RCPointerArray<CSoftwareTypeRegInfo> regInfoArray;

	CleanupClosePushL(regInfoArray);

	CSoftwareTypeRegInfoParser* parser = CSoftwareTypeRegInfoParser::NewL();

	CleanupStack::PushL(parser);

	parser->ParseL(*buf, regInfoArray);

	// Pack the registration data

	RBuf8 serializedRegInfo;

	serializedRegInfo.CleanupClosePushL();

	SoftwareTypeRegInfoUtils::SerializeArrayL(regInfoArray, serializedRegInfo);

	aMessage.Write(2, serializedRegInfo);

	CleanupStack::PopAndDestroy(5, &file); // buf, regInfoArray, parser, serializedRegInfo

	}

	{

	RegisterSifLauncherMimeTypesImplL(aMessage, ETrue);

	}

	{

	RegisterSifLauncherMimeTypesImplL(aMessage, EFalse);

	}

	{

	// Read serialized MIME types from aMessage

	HBufC8* buf = HBufC8::NewLC(aMessage.GetDesLengthL(0));

	TPtr8 bufPtr(buf->Des());

	aMessage.ReadL(0, bufPtr);

	// Unserialize MIME types

	RDesReadStream rs(*buf);

	CleanupClosePushL(rs);

	RCPointerArray<HBufC8> mimeTypes;

	CleanupClosePushL(mimeTypes);

	InternalizePointerArrayL(mimeTypes, rs);

	// Connect to AppArc

	RApaLsSession apa;

	TInt err = apa.Connect();

	if (err != KErrNone)

		{

		DEBUG_PRINTF2(_L8("Failed to connect to the AppArc server, err = %d\n"),err);