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

//

#include "uloggerclient.h"

#include "uloggershared.h" 

#include "uloggertools.h"

#include "uloggercommands.h"

#include <e32math.h>

#include <e32base.h>

#include <badesca.h>

namespace Ulogger

{

//declarations

static const TUint KMessageSlots = 32;

///////////////////////////////////////////////////////////////////

//

// Definition of RULogger methods...

//

///////////////////////////////////////////////////////////////////

//constructor

EXPORT_C RULogger::RULogger()

	{

	}//</constructor>

//destructor

EXPORT_C RULogger::~RULogger()

	{

	Close();

	}//</destructor>

EXPORT_C TInt RULogger::Connect()

	{

	TInt retVal = StartServer();

	if((KErrNone == retVal) || (KErrAlreadyExists == retVal))

		{

		retVal = CreateSession(KServerName, this->Version(), KMessageSlots);

		}

	return retVal;	

	}

EXPORT_C TInt RULogger::RunAsService(TBool /*aRunAsService*/)

	{

	TInt retVal;

	retVal = KErrNotSupported; // Replace with SendReceive call once functionality implemented in server

//

// // Replace above with following, once functionality implemented in server:

//

//	if (aRunAsService)

//		retVal = SendReceive(ERunAsService);

//	else

//		retVal = SendReceive(EDontRunAsService);

//

	return retVal;

	}

EXPORT_C TInt RULogger::Start()

	{

	return SendReceive(EStart);	

	}

EXPORT_C TInt RULogger::Stop()

	{

	return SendReceive(EStop);

	}

EXPORT_C TInt RULogger::Restart()

	{

	return SendReceive(ERestart);

	}

EXPORT_C TInt RULogger::SetPrimaryFiltersEnabled(const CArrayFixFlat<TUint8>& aFilters, TBool aEnabled)

	{

	TInt retVal = KErrNone;

	//externalize filters array to string to send it in either a

	//ESetPrimaryFilter or ERemovePrimaryFilter message, but only if at least

	//one filter was actually specified in the filters array

	if(aFilters.Count())

		{

		//prepare data to send

		HBufC8 *des  = NULL;

		TRAP(retVal, des = ExternalizeToBufL((const CArrayFix<TUint8>&) aFilters, sizeof(TUint8)));

		if(KErrNone == retVal)

			{

			//send data

			TPtr8 dataPtr(des->Des());

			TIpcArgs args(&dataPtr, aFilters.Count());

			if (aEnabled)

				retVal = SendReceive(ESetPrimaryFilter, args);

			else

				retVal = SendReceive(ERemovePrimaryFilter, args);

			}

		delete des;

		}

	else

		retVal = KErrArgument;

	/**r

	if(retVal == KErrAlreadyExists)

		retVal = KErrNone;

		*/

	return retVal;

	}

EXPORT_C TInt RULogger::GetPrimaryFiltersEnabled(CArrayFixFlat<TUint8>& aFilters)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(256);

	if(buf)

		{

		TPtr8 ptr(buf->Des());

		TIpcArgs args(&ptr);

		retVal = SendReceive(EGetPrimaryFilters, args);

		if (KErrNone == retVal)

			{

			TUint8 tmp = 1;

			TRAP(retVal, InternalizeFromBufL(*buf, aFilters, tmp));

			}

		delete buf;

		buf = NULL;

		}

	else

		{

		return KErrNoMemory;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::SetSecondaryFiltersEnabled(const RArray<TUint32>& aFilters, TBool aEnabled)

	{

	TInt retVal = KErrNone;

	//ensure max secondary filters limit isn't exceeded, otherwise return error

	if (aFilters.Count() > KMaxSecondaryFiltersLimit)

		{

		retVal = KErrArgument;

		}

	else

		{

		//externalize filters array to string to send it in either a

		//ESetSecondaryFilter or ERemoveSecondaryFilter message, but only if at least

		//one filter was actually specified in the filters array

		if(aFilters.Count())

			{

			//prepare data to send

			HBufC8 *des = NULL;

			TRAP(retVal, des = ExternalizeToBufL(aFilters, sizeof(TUint32)));

			if(KErrNone == retVal)

				{

				//send data

				TPtr8 dataPtr(des->Des());

				TIpcArgs args(&dataPtr, aFilters.Count());

				if (aEnabled)

					retVal = SendReceive(ESetSecondaryFilter, args);

				else

					retVal = SendReceive(ERemoveSecondaryFilter, args);

				}

			//clean up string if necessary

			delete des;

			}

		else

			retVal = KErrArgument;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::GetSecondaryFiltersEnabled(RArray<TUint32>& aFilters)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(KMaxSecondaryFiltersLimit*sizeof(TUint32));

	if(buf)

		{

		TPtr8 ptr(buf->Des());

		TIpcArgs args(&ptr);

		retVal = SendReceive(EGetSecondaryFilters, args);

		if(KErrNone == retVal)

			{

			TUint32 tmp=1;

			TRAP(retVal, InternalizeFromBufL(*buf, aFilters, tmp));

			}

		delete buf;

		buf = NULL;

		}

	else

		{

		retVal = KErrNoMemory;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::SetSecondaryFilteringEnabled(TBool aEnabled)

	{

	TInt retVal;

	if (aEnabled)

		retVal = SendReceive(EEnableSecondaryFiltering);

	else

		retVal = SendReceive(EDisableSecondaryFiltering);

	return retVal;

	}

EXPORT_C TInt RULogger::GetSecondaryFilteringEnabled(TBool& aEnabled)

	{

	//this code is a copy of GetModuleUidFiltering && GetBuffer && Notification etc etc....

	//should put all of it in a separate method...

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(200);

	if(buf)

		{

		//send request to server

		TPtr8 ptr(buf->Des());

		TIpcArgs args(&ptr);

		retVal = SendReceive(EGetSecondaryFiltering, args);

		if(!retVal)

			{

			TLex8 val(ptr);

			retVal = val.Val(aEnabled);

			}

		delete buf;

		buf = NULL;

		}

	else

		{

		retVal = KErrNoMemory;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::ActivateOutputPlugin(const TDesC8& aPluginName)

	{

	TIpcArgs iArgs; //Ipc arguments

	iArgs.Set(0, &aPluginName);

	return SendReceive(ESetActivePlugin, iArgs);

	}

EXPORT_C TInt RULogger::GetActiveOutputPlugin(TDes8& aPluginName)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(2048); // Need to push on stack in that case

	// does it matter if its 8 or 16 buf?

	if(buf)

		{

		//send get active output plug-in message

		TPtr8 ptr(buf->Des());

		TIpcArgs args;

		args.Set(0, &ptr);

		retVal = SendReceive(EGetActivePlugin, args);

		//parse response buffer

		TInt pos = 0;

		if(pos != KErrNotFound)

			{

			pos = buf->Des().Find(KSeparator); // Find separator

			//just don't send the separator?

			if(pos >= 0)

				{

				TPtrC8 ptrVal(buf->Des().Left(pos));

				if (aPluginName.MaxLength() < pos)

					retVal = KErrOverflow;

				else

					aPluginName.Copy(ptrVal);

				}

			}

		delete buf;

		buf = NULL;

		}

	else

		{

		retVal = KErrNoMemory;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::GetInstalledOutputPlugins(CArrayPtrFlat<HBufC8>& aPluginNames)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(2048);

	if(buf)

		{

		TPtr8 ptr(buf->Des());

		TIpcArgs args;

		args.Set(0, &ptr);

		retVal = SendReceive(EGetInstalledPlugins, args);

		//parse buffer

		TInt pos = KErrNone;

		TInt err = KErrNone;

		while(pos != KErrNotFound)

			{

			pos = buf->Des().Find(KSeparator);

			if(pos > 0)	

				{

				TPtrC8 ptrVal(buf->Des().Left(pos));

				HBufC8 *bufDes = HBufC8::New(ptrVal.Length()+8);

				if(bufDes)

					{

					bufDes->Des().Copy(ptrVal);

					TRAP(err, aPluginNames.AppendL(bufDes));

					}

				buf->Des().Delete(0,pos+1);

				}

			}

		delete buf;

		buf = NULL;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::ActivateInputPlugin(const TDesC8& aPluginName)

	{

	TIpcArgs iArgs;

	iArgs.Set(0, &aPluginName);

	return SendReceive(ESetActiveInputPlugin, iArgs);

	}

EXPORT_C TInt RULogger::GetActiveInputPlugin(TDes8& aPluginName)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(1024);// Push on stack in that case

	if(buf)

		{

		//send get active input plug-in message

		TPtr8 ptr(buf->Des());

		TIpcArgs args;

		args.Set(0, &ptr);

		retVal = SendReceive(EGetActiveInputPlugin, args);

		//parse response buffer

		TInt pos = KErrNone;

		if(pos != KErrNotFound)

			{

			pos = buf->Des().Find(KSeparator);

			if(pos >= 0)

				{

				buf->Des().Delete(0, pos+1); // Get rid of media number + separator

				pos = buf->Des().Find(KSeparator); // Find separator after plug-in name

				if(pos >= 0)	

					{

					TPtrC8 ptrVal(buf->Des().Left(pos));

					if (aPluginName.MaxLength() < pos)

						retVal = KErrOverflow;

					else

						aPluginName.Copy(ptrVal);

					}

				}

			}

		delete buf;

		buf = NULL;

		}

	else

		{

		retVal = KErrNoMemory;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::DeActivateInputPlugin()

	{

	TInt retVal = KErrNone;

	//get currently active input plug-in name

	TBuf8<KMaxPath> activePluginName;

	retVal = GetActiveInputPlugin(activePluginName);

	//deactivate currently active input plug-in

	if (KErrNone == retVal)

		{

		TIpcArgs iArgs;

		iArgs.Set(0, &activePluginName);

		retVal = SendReceive(EDeactivateInputPlugin, iArgs);

		}

	return retVal;

	}

EXPORT_C TInt RULogger::GetInstalledInputPlugins(CArrayPtrFlat<HBufC8>& aPluginNames)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(2048);//Push on stack in that case

	if(buf)

		{

		TPtr8 ptr(buf->Des());

		TIpcArgs args;

		args.Set(0, &ptr);

		retVal = SendReceive(EGetInputPlugins, args);

		//parse buffer

		TInt pos = KErrNone;

		TInt err = KErrNone;

		while(pos != KErrNotFound)

			{

			pos = buf->Des().Find(KSeparator);

			if(pos > 0)	

				{

				TPtrC8 ptrVal(buf->Des().Left(pos));

				HBufC8 *bufDes = HBufC8::New(ptrVal.Length()+8);//push on stack

				if(bufDes)

					{

					bufDes->Des().Copy(ptrVal);

					TRAP(err, aPluginNames.AppendL(bufDes));

					}

				buf->Des().Delete(0,pos+1);

				}

			}

		delete buf;

		buf = NULL;

		}

	return retVal;

	}

EXPORT_C TInt RULogger::SetPluginConfigurations(const TDesC8& aPluginName, const TPluginConfiguration& aConfiguration)

	{

	TInt retVal = KErrNone;

	if(aConfiguration.Key().Length()==0||aConfiguration.Value().Length()==0)

		return KErrArgument;

	//count total_length + separators

	TInt length = 1;

	length+=aConfiguration.Key().Length()+aConfiguration.Value().Length()+2;

	HBufC *configs = HBufC::New(length);// Push on stack in that case

	if(configs)

		{

		TPtr formatConfigs(configs->Des());

		formatConfigs.AppendFormat(KConfigFormat, &(aConfiguration.Key()), &(aConfiguration.Value()));

		HBufC8 *settings= HBufC8::NewLC(configs->Length());//Push on stack in that case

		if(settings)

			{

			settings->Des().Copy(configs->Des());

			TPtr8 arg2(settings->Des());

			TIpcArgs args; //Ipc arguments

			args.Set(0, &aPluginName);

			args.Set(1, &arg2);

			retVal = SendReceive(ESetPluginSettings,args);

			CleanupStack::PopAndDestroy(settings); 

			}

		else

			return KErrNoMemory;

		delete configs;

		}

	else

		return KErrNoMemory;

	return retVal;

	}

EXPORT_C TInt RULogger::GetPluginConfigurations(const TDesC8& aPluginName, RPointerArray<TPluginConfiguration>& aConfigurations)

	{

	TInt retVal = KErrNone;

	HBufC8 *buf = HBufC8::New(2048);//Push on stack in that case

	if(buf)

		{

		TPtr8 ptr(buf->Des());

		HBufC8 *mediaBuf = HBufC8::New(1+aPluginName.Length());// push on stack if we need to alloc this. Don't hardcode!!

		if(mediaBuf)

			{

			mediaBuf->Des().Copy(aPluginName);

			TPtr8 mediaPtr(mediaBuf->Des());

			//send data

			TIpcArgs args;

			args.Set(0, &mediaPtr);

			args.Set(1, &ptr);

			retVal = SendReceive(EGetPluginSettings, args);

			//parse received buffer

			TInt pos = buf->Des().Find(KSeparator);

			while((pos != KErrNotFound) && (retVal == KErrNone))

				{

				TPluginConfiguration* pluginConfig = new TPluginConfiguration();// Push on stack in that case

				//memory leak? not always deleted?

				if (pluginConfig)

					{

					TPtrC8 ptrKey(buf->Des().Left(pos));

					pluginConfig->SetKey(ptrKey);