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