client.cpp

hercules v9 symbian os application development

// client.cpp

#include "client.h"
#include "client-server.h"
#include <e32math.h>

// Runs client-side and starts the separate server process
static TInt StartTheServer()
	{
	RProcess server;
	TInt r=server.Create(KServerBinaryName, KNullDesC);
	if (r!=KErrNone)
		return r;
	
	TRequestStatus stat;
	server.Rendezvous(stat);
	if (stat!=KRequestPending)
		server.Kill(0);		// abort startup
	else
		server.Resume();	// logon OK - start the server
	
	User::WaitForRequest(stat);		// wait for start or death
	
	// Check the exit type.
	// We can't use the 'exit reason' because if the server panicked this
	// is set to the panic 'reason' (which may be '0' and cannot thus be distinguished
	// from KErrNone)
	r = server.ExitType();
	if (EExitPanic==r)
		r = KErrGeneral; 
	else
		r = stat.Int();
	
	server.Close(); // This is no longer needed
	return r;
	}



EXPORT_C TInt RHerculesSession::Connect()
	{
	TInt retry=2;
	for (;;)
		{// Uses system-pool message slots
		TInt r=CreateSession(KServerName,TVersion(1,0,0));
		if ( (KErrNotFound!=r) && (KErrServerTerminated!=r) )
			return (r);
		if (--retry==0)
			return (r);
		r=StartTheServer();
		if ( (KErrNone!=r) && (KErrAlreadyExists!=r) )
			return (r);
		}
	}

// Request which passes a "read only" integer and a constant descriptor to the server
EXPORT_C TInt RHerculesSession::SlayNemeanLion(const TDesC8& aDes, TInt aVal)
	{
	TIpcArgs args(&aDes,aVal);
	return (SendReceive(ESlayNemeanLion,args));
	}

// Request which passes a read/write integer to the server
EXPORT_C TInt RHerculesSession::CaptureCeryneianHind(TInt& aCaptureCount)
	{
	TPckg<TInt> countBuf(aCaptureCount);	
	TIpcArgs args(&countBuf);
	return (SendReceive(ECaptureCeryneianHind,args));
	}

// Request which passes a T class object
EXPORT_C TInt RHerculesSession::SlayHydra(THydraData& aData)
	{
	TPckg<THydraData> data(aData);
	TIpcArgs args(&data);
	return (SendReceive(ESlayHydra,args));
	}

// Request passes a C class object
EXPORT_C TInt RHerculesSession::SlayErymanthianBoar(const CHerculesData& aData)
	{
	HBufC8* dataDes=NULL;
	TRAPD(r, dataDes = aData.MarshalDataL());
	if (dataDes)
		{
		TPtr8 ptr(dataDes->Des());
		TIpcArgs args(&ptr);
		r = SendReceive(ESlayErymanthianBoar, args);
		delete dataDes;
		}

	return (r);
	}

// Asynchronous request
EXPORT_C void RHerculesSession::CleanAugeanStables(TRequestStatus& aStatus)
	{
	SendReceive(ECleanAugeanStables, TIpcArgs(), aStatus);
	}

// Cancels the CleanAugeanStables() asynchronous request
EXPORT_C void RHerculesSession::CancelCleanAugeanStables()
	{
	SendReceive(ECancelCleanAugeanStables, TIpcArgs());
	}

// Asynchronous request which passes a read only integer and modifiable descriptor
EXPORT_C void RHerculesSession::SlayStymphalianBirds(TInt aCount, TDes8& aData, TRequestStatus& aStatus)
	{
	TIpcArgs args(aCount, &aData);
	SendReceive(ESlayStymphalianBirds, args, aStatus);
	}

// Cancels the SlayStymphalianBirds() asynchronous request
EXPORT_C void RHerculesSession::CancelSlayStymphalianBirds ()
	{// Every asynchronous request should have a cancellation method
	SendReceive(ECancelSlayStymphalianBirds, TIpcArgs());
	}