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

 // e32test/mmu/t_shbuf_perfclient.cpp

 //

 //

 #include <e32std.h>

 #include <e32cmn.h>

 #include <e32debug.h>

 #include <e32msgqueue.h>

 #include <e32shbuf.h>

 #include "t_shbuf_perfserver.h"

 #include "t_shbuf_perfclient.h"

 /**

  *  @file

  * 

  *  Client side APIs for a test server used for Performance Testing of shared buffers.

  */

 /**

  *  Test API version.

  */

 const TInt KRShBufTestServerMajorVersion = 1;

 const TInt KRShBufTestServerMinorVersion = 0;

 const TInt KRShBufTestServerBuildVersion = 1;

 /**

  *  Start the server process which lives in its own executable and rendezvous with it.

  *

  *  @return  KErrNone if successful, or an error code if not.

  */

 static TInt StartTestServer()

 	{

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 	//

 	// Create a new server process. Simultaneous launching of two such

 	// processes should be detected when the second one attempts to

 	// create the server object, failing with KErrAlreadyExists.

 	//		

 	_LIT(KTestServerExeImg, "T_SHBUF_PERFSERVER.EXE");

 	RProcess server;

 	TInt  ret = server.Create(KTestServerExeImg, KNullDesC);

 	if (ret != KErrNone)

 		{

 		return ret;

 		}

 #else

 	//

 	// Start a thread with the server in it.

 	//		

 	RThread  server;

 	TInt  ret = server.Create(_L("RShBufTestServerThread"), RShBufTestServerThread,

 							  KDefaultStackSize, 0x10000, 0x10000, NULL);

 	if (ret != KErrNone)

 		{

 		return ret;

 		}

 #endif

 	//

 	// Rendezvous with the server or abort startup...

 	//

 	TRequestStatus  status;

 	server.Rendezvous(status);

 	if (status != KRequestPending)

 		{

 		server.Kill(0);

 		}

 	else

 		{

 		server.Resume();

 		}

 	User::WaitForRequest(status);

 	//

 	// 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.

 	//

 	if (server.ExitType() == EExitPanic)

 		{

 		ret = KErrGeneral;

 		}

 	else if (status.Int() != KErrAlreadyExists)

 		{

 		ret = status.Int();

 		}

 	server.Close();

 	return ret;

 	} // StartTestServer

 /**

  *  Standard constructor.

  */

 EXPORT_C RShBufTestServerSession::RShBufTestServerSession()

 	{

 	// NOP

 	} // RShBufTestServerSession::RShBufTestServerSession

 /**

  *  Connects the client to the test server. 

  *

  *  @return  KErrNone if successful, a system-wide error code if not. 

  *

  *  @capability None

  */

 EXPORT_C TInt RShBufTestServerSession::Connect()

 	{

 	//

 	// Create a session with the server, but if it doesn't exist then start it and

 	// then create a session.

 	//

 	TInt  result = CreateSession(KRShBufTestServerName,

 								 TVersion(KRShBufTestServerMajorVersion,

 	                					  KRShBufTestServerMinorVersion,

 	                					  KRShBufTestServerBuildVersion));

 	if (result == KErrNotFound  ||  result == KErrServerTerminated)

 		{

 		result = StartTestServer();

 		if(result == KErrNone)

 			{

 			result = CreateSession(KRShBufTestServerName,

 								   TVersion(KRShBufTestServerMajorVersion,

 	                					    KRShBufTestServerMinorVersion,

 	                					    KRShBufTestServerBuildVersion));

 			}

 		}	

 	//

 	// If the creation of the session fails clean up session data...

 	//

 	if (result != KErrNone)

 		{

 		Close();

 		}

 	return result;

 	} // RShBufTestServerSession::Connect

 /**

  *  Closes the client's session with the RShBuf Test Server. 

  *

  *  @capability None

  */

 EXPORT_C void RShBufTestServerSession::Close()

 	{

 	RSessionBase::Close();

 	} // RShBufTestServerSession::Close

 /**

  *  Returns the current version of the RShBuf Test Server.

  *

  *  @return The version of the RShBuf Test Server. 

  *

  *  @capability None

  */

 EXPORT_C TVersion RShBufTestServerSession::Version() const

 	{

 	return(TVersion(KRShBufTestServerMajorVersion,

 	                KRShBufTestServerMinorVersion,

 	                KRShBufTestServerBuildVersion));

 	} // RShBufTestServerSession::Version

 /**

  *  Requests the shutdown of the server when the last client disconnects.

  *  There is no support for immediate shutdown functionality. This API call

  *  can only be executed if the server is compiled as a debug release.

  *  

  *  @return  KErrNone if successful, a system-wide error code if not. 

  */

 EXPORT_C TInt RShBufTestServerSession::ShutdownServer()

 	{	

 	return SendReceive(EShBufServerShutdownServer, TIpcArgs());

 	} // RShBufTestServerSession::ShutdownServer

 EXPORT_C TInt RShBufTestServerSession::FromTPtr8ProcessAndReturn(TDes8& aBuf, TUint aBufSize)

 	{

 	TIpcArgs  args(&aBuf, aBufSize);

 	return SendReceive(EShBufServerFromTPtr8ProcessAndReturn, args);

 	} // RShBufTestServerSession::FromTPtr8ProcessAndReturn

 EXPORT_C TInt RShBufTestServerSession::FromTPtr8ProcessAndRelease(const TDesC8& aBuf)

 	{

 	TIpcArgs  args(&aBuf);

 	return SendReceive(EShBufServerFromTPtr8ProcessAndRelease, args);

 	} // RShBufTestServerSession::FromTPtr8ProcessAndRelease

 EXPORT_C TInt RShBufTestServerSession::FromRShBufProcessAndReturn(RShBuf& aShBuf, TUint aBufSize)

 	{

 	TInt r;

 	TInt handle;

 	TPckg<TInt> handlePckg(handle);

 	TIpcArgs  args(&handlePckg, aBufSize);

 	r = SendReceive(EShBufServerFromRShBufProcessAndReturn, args);

 	if (r == KErrNone)

 	    aShBuf.SetReturnedHandle(handle);

 	return r;

 	} // RShBufTestServerSession::FromRShBufProcessAndReturn

 EXPORT_C TInt RShBufTestServerSession::OpenRShBufPool(TInt aHandle, const TShPoolInfo& aShPoolInfo)

 	{

 	TPckg<TShPoolInfo>  shPoolInfoPckg(aShPoolInfo);

 	TIpcArgs  args(aHandle, &shPoolInfoPckg);

 	return SendReceive(EShBufServerOpenRShBufPool, args);

 	} // RShBufTestServerSession::OpenRShBufPool

 EXPORT_C TInt RShBufTestServerSession::CloseRShBufPool(TInt aHandle)

 	{

 	TIpcArgs  args(aHandle);

 	return SendReceive(EShBufServerCloseRShBufPool, args);

 	} // RShBufTestServerSession::CloseRShBufPool

 EXPORT_C TInt RShBufTestServerSession::FromRShBufProcessAndRelease(RShBuf& aShBuf)

 	{

 	TIpcArgs  args(aShBuf.Handle());

 	return SendReceive(EShBufServerFromRShBufProcessAndRelease, args);

 	} // RShBufTestServerSession::FromRShBufProcessAndRelease

 /**

  *  Set a heap mark in the RShBuf Test Server thread.

  *

  *  @capability None

  */

 EXPORT_C TInt RShBufTestServerSession::__DbgMarkHeap()

 	{

 	TIpcArgs args(TIpcArgs::ENothing);

 	return SendReceive(EShBufServerDbgMarkHeap, args);

 	} // RShBufTestServerSession::__DbgMarkHeap

 /**

  *  Performs a heap mark check in the RShBuf Test Server thread.

  *

  *  @param aCount  The number of heap cells expected to be allocated at

  *                 the current nest level.

  *

  *  @capability None

  */

 EXPORT_C TInt RShBufTestServerSession::__DbgCheckHeap(TInt aCount)

 	{

 	TIpcArgs args(aCount);

 	return SendReceive(EShBufServerDbgCheckHeap, args);

 	} // RShBufTestServerSession::__DbgCheckHeap

 /**

  *  Perfom a heap mark end check in the RShBuf Test Server thread.

  *

  *  @param aCount  The number of heap cells expected to remain allocated

  *                 at the current nest level.

  *

  *  @capability None

  */

 EXPORT_C TInt RShBufTestServerSession::__DbgMarkEnd(TInt aCount)

 	{

 	TIpcArgs args(aCount);

 	return SendReceive(EShBufServerDbgMarkEnd, args);

 	} // RShBufTestServerSession::__DbgMarkEnd

 /**

  *  Set a heap fail next condition in the RShBuf Test Server thread.

  *

  *  @param aCount  Determines when the allocation will fail.

  *

  *  @capability None

  */

 EXPORT_C TInt RShBufTestServerSession::__DbgFailNext(TInt aCount)

 	{

 	TIpcArgs args(aCount);

 	return SendReceive(EShBufServerDbgFailNext, args);

 	} // RShBufTestServerSession::__DbgFailNext