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

// All rights reserved.

// This component and the accompanying materials are made available

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

// RStartProcess Client side header

// Implements the R class to start server process

// 

//

/**

 @file 

*/

#include "startprocess.h"

#include <e32math.h>

/*

* Start process has to be different for EPOC32 (EKA1/EKA2 - started as a process) and emulator 

* (should be started as a DLL in a separate thread)

*/

TInt RStartProcess::StartProcess()

/** 

 * Starts the process and waits for a completion

 *

 * @return system error code

 */

	{

	//

	// on EPOC platform. Simultaneous launching

	// of two such processes should be detected when the second one attempts to

	// create the process object, failing with KErrAlreadyExists.

	//

	TBuf<KMaxFileNameLength> serverFile;

	_LIT(KExe, ".exe");

	serverFile.Copy( iName );

	serverFile.Append(KExe);

 	// Remove any "!" prefix when forming the server binary filename.  This is because only

 	// a single string is passed into CStartServer and used to form both the server name

 	// and server binary filename.  However, for protected servers, the string will have

 	// a "!" prefix - this is used for the server name but removed for the binary filename.

 	_LIT(KExclamationMark, "!");

 	if (serverFile.Left(1).Compare(KExclamationMark()) == 0)

 		serverFile.Delete(0,1);

	TInt res = iProcess.Create( serverFile,KNullDesC );

	return res == KErrNone ? WaitForCompletion() : res;

	}

TInt RStartProcess::StartProcessThreadFn(TAny* aStartProcess)

	{//logon completes with the return code

	return static_cast<RStartProcess*>(aStartProcess)->StartProcess();	

	}

TInt RStartProcess::WaitForCompletion()

	{

	TRequestStatus started;

	iProcess.Rendezvous(started);

	TRequestStatus died;

	iProcess.Logon(died);

	if (died!=KRequestPending)

		{

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

		User::WaitForRequest(died);	// eat signal

		iProcess.Kill(0);				// abort startup

		iProcess.Close();

		return died.Int();

		}

	//

	// logon OK - start the process

	iProcess.Resume();

	User::WaitForRequest(started,died);		// wait for start or death

	if (started==KRequestPending)

		{

		// process has died, never made it to the startup signal

		iProcess.Close();

		return died.Int();

		}

	//

	// process started (at last). Cancel and consume the death-notification

	// before reporting success

	iProcess.LogonCancel(died);

	User::WaitForRequest(died);		// eat the signal (from the cancel)

	iProcess.Close();

	return iErrorCode;

	}

EXPORT_C void RStartProcess::Cancel()

/**

* Intended to cancel asynchronous process startup.

*

*/

	{//not sure what this can do => kill the thread maybe

	//for the time being when cancel occures nothing happens and user must still wait

	//for start-up to finish

   //for the time being we end up blocking our thread until the startup has finished

   //and than we call. 

   //NOTE At the minute we don't kill the process when cancel is called we just set the error code

   //and wait for the process to synchronise anyway

   //iProcess.Kill( KErrCancel );

	iErrorCode = KErrCancel; //indicate the error code

	}

EXPORT_C TInt RStartProcess::Start(const TDesC& aName, TRequestStatus& aStatus)

/**

* Starts the process asynchronously (using a thread)

*

* @param aName name of the process DLL/EXE

* @param aStatus

* @return TInt - An error code

*/

	{

	iErrorCode = KErrNone;

	iName.Des().Copy(aName);

	TName name(iName);

	TTime now;

	now.HomeTime();

	TInt64 seed = now.Int64();

	name.AppendNum(Math::Rand(seed), EHex);

	//start the process process using a thread => asynch

	RThread t;

	const TUint KStackSize=0x1000;

	if ((iErrorCode=t.Create(name, StartProcessThreadFn, KStackSize, NULL/*reuses our heap*/, this)) == KErrNone)

		{

		t.Logon(aStatus);

		t.Resume(); //RStartProcess::StartProcessThreadFn completes the logon

		t.Close();

		}

	else

		{

		TRequestStatus* p=&aStatus;

		User::RequestComplete( p, iErrorCode );

		}

	return iErrorCode;

	}

EXPORT_C TInt RStartProcess::Start(const TDesC& aName)

/**

* Starts the process synchronously

*

* @param aName name of the process DLL/EXE

* @return TInt - An error code

*/

	{

	iName.Des().Copy(aName);

	iErrorCode = KErrNone;

	return StartProcessThreadFn(this);		

	}