// Copyright (c) 2007-2010 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 <e32const.h>

#include <e32btrace.h>

#include <f32file.h>

#include "uloggerserver.h"

#include "uloggersession.h"

#include "uloggerclient.h"

#include "uloggerplugin.h"

#include "uloggershared.h"

#include "uloggerdatatypes.h"

#include "inputdata.h"

#include "uloggercommands.h"

#if defined(__LIGHTLOGGER_ENABLED)

#include "lightlogger.h" 

#endif

namespace Ulogger {

/*Default constructor*/

CULoggerServer::CULoggerServer(TInt aPriority)

: CServer2( aPriority )

{

	iIsBooting = ETrue;

	iConfigManager = NULL;

	iDataWatcher = NULL;

	iOutputFramework = NULL;

	iInputFramework = NULL;

	iPluginAllocator = NULL;

}

/** Destructor will be called before re-starting

*/

CULoggerServer::~CULoggerServer()

{

	delete iConfigManager;

	delete iOutputFramework;

	delete iInputFramework;

	delete iPluginAllocator;

	iPluginArray.ResetAndDestroy();

	iPluginArray.Close();

    if(iDataWatcher)

    	{

    	iDataWatcher->Cancel();

    	delete iDataWatcher; 

    	}

}

/** Static Factory Construction 

@return a pointer to the created object

@leave KErrNoMemory if not enough memory available

*/

CULoggerServer* CULoggerServer::NewLC(TInt aPriority)

{

	CULoggerServer* self = new (ELeave) CULoggerServer( aPriority );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

}

/**

Create and install new Framework & Active Scheduler

*/

void CULoggerServer::ConstructL()

{

	iRunAsService = EFalse; // Not used yet, to be used for run-as-service functionality

	iBufferSize = KMaxBufferSize;

	iBtraceOpen = EFalse;

	iDataNotification = 0;

	StartL( KServerName );	

	iConfigManager = CConfigFileManager::NewL();

}

/**

Create a new server session. 

@note Called by kernel after client's thread use any of the macros for the first time.

*/

CSession2* CULoggerServer::NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const

{

 	TVersion v(KULoggerSrvMajorVersionNumber,KULoggerSrvMinorVersionNumber,KULoggerSrvBuildVersionNumber);

    if (!User::QueryVersionSupported(v,aVersion))

         User::Leave(KErrNotSupported);

	RThread client;

	aMessage.Client(client);

	return CULoggerSession::NewL( client, *const_cast<CULoggerServer*>(this) );

}

/*Increment session counter*/

void CULoggerServer::IncrementSessions()

{	

	++iSessionCounter;

}

/*Decrement session counter*/

void CULoggerServer::DecrementSessions()

	{

	if(--iSessionCounter <= 0)

		{

		if (!iBtraceOpen)

			ShutDownServer();

//

// // Replace above if-statement with following to implement run-as-service functionality

//

//		if((!iBtraceOpen) && (!iRunAsService))

//			ShutDownServer();

//

		}

	}

/*!

Shuts down the server

*/

void CULoggerServer::ShutDownServer()

{

	CActiveScheduler::Stop();

}//</ShutDownServer>

/*!

Return the error value

*/

TInt CULoggerServer::RunError(TInt aError)

{

	Message().Complete(aError);

	ReStart();

	return KErrNone;

}

void CULoggerServer::PanicServer(TULoggerSrvPanics aPanic)

{

	User::Panic(KServerName, aPanic);

}//</PanicServer>

/*!

*/

void CULoggerServer::PanicClient(const RMessage2& aMessage, TULoggerSrvPanics aPanic)

{

	aMessage.Panic( KServerName, aPanic );

}//</PanicClient>

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

/**

ServerL

@Installs the active scheduler

@Opens the semaphore

*/

TInt CULoggerServer::StartServerL()

{

	#if defined(__LIGHTLOGGER_ENABLED)

	__CREATE_LOG(EFalse)

	__HIRES_RESOLUTION

	#endif	

    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler();

    CleanupStack::PushL(activeScheduler) ;

    CActiveScheduler::Install(activeScheduler);

    CULoggerServer* server = NULL;

	TInt servererr = KErrNone;

	TRAP(servererr,

		{

		server = CULoggerServer::NewLC((TProcessPriority)EPriorityHigh);

		CleanupStack::Pop();

		});

	if(servererr==KErrNone||servererr==KErrNotFound )

		{

		RProcess::Rendezvous(KErrNone);

		servererr=KErrNone;

		CActiveScheduler::Start();

		}

	else

		{

		RProcess::Rendezvous(servererr);		

		}

	delete server;

   	CleanupStack::PopAndDestroy();

	return servererr;

}//</StartingFunctionL>

/**

Function to to start the server 

This should leave with KErrNone 

*/

TInt CULoggerServer::StartServer()

{

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if (!cleanupStack)

	{

        	return KErrNoMemory;

	}

	TInt err;

    TRAP(err, StartServerL());

    delete cleanupStack;

    cleanupStack = NULL;

    return err;

}//</StartingFunction>

/**

Function to set the active output media 

This should leave with KErrNotFound if given plugin is not the correct one

or the file doesn't exists in the user and public path

*/

TInt CULoggerServer::SetActiveOutputPlugin(const TDesC8 &aPluginname)

{

	RArray<TPtrC8> activePluginsArray;

	TInt error= KErrNone;

	error = GetInstalledOutputPlugins(activePluginsArray);

	if(error==KErrNone)

		{

		for(TInt i=0;i<activePluginsArray.Count();i++)

			{

			if(aPluginname.Compare(activePluginsArray[i])==0)

				{

				error = iConfigManager->SetActiveOutputPlugin(aPluginname);

				break;

				}	

			else 

				error = KErrNotFound;

			}

		}

	if(error == KErrAlreadyExists)

		{

		error=KErrNone;

		}

	return error;

}

TInt CULoggerServer::SetActiveInputPlugin(const TDesC8 &aPluginname)

	{

	RArray<TPtrC8> activePluginsArray;

	TInt ret= KErrNone;

	//check configuration file in user path (\\ulogger\\uloggerconfig.ini)	

	ret = GetInstalledInputPluginsL(activePluginsArray);

	if(ret==KErrNone)

		{

		ret = KErrNotFound;

		for(TInt i=0;i<activePluginsArray.Count();i++)

			{

			if(aPluginname.Compare(activePluginsArray[i])==0)

				{

				ret = iConfigManager->SetActiveInputPlugin(aPluginname);

				break;	

				}

			}

		}

	return ret;

	}

/**

Function to set the plugin settings

This should leave with KErrNotFound if cannot file doesn't exist

*/

TInt CULoggerServer::SetPluginSettings(const TDesC8 &aPluginname, RArray<TPtrC8>& aListBuffer)

{	

	TInt i = 0;

	TInt ret=KErrNone;

	//if plug-in doesn't exists

	TPtrC8 pluginName(aPluginname);

	if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))

		return KErrNotFound;

	while(i<aListBuffer.Count())

		{

		TPtrC8 key(aListBuffer[i]);

		TPtrC8 val(aListBuffer[++i]);

		ret = iConfigManager->SetPluginSetting(aPluginname, key, val);

		if(ret!=KErrNone)

			break;

		i++;		

		}					

	return ret;

}

/**

Function to get the plugin settings

This should leave with KErrNotFound if cannot find one

*/

TInt CULoggerServer::GetOptionsSettingsL(const TDesC8 &aMediaName, RArray<TPtrC8>& aListBuffer)

{

	//if plug-in doesn't exists

	TPtrC8 pluginName(aMediaName);

	if(!CheckPluginExists(pluginName, EOutputPluginFilter) && !CheckPluginExists(pluginName, EInputPluginFilter))

		return KErrNotFound;

	else

		{

		TInt ret = GetValuesL(aMediaName,aListBuffer);

		if(ret == KErrNotFound) //this error indicate that there is no section in config file, plug-in exists

			ret = KErrNone;

		return ret;

		}

}

/**

Function to get values from the configuration file (i.e. for filters,plugin settings)

This should leave with KErrNotFound if it cannot find the configuration file

*/

TInt CULoggerServer::GetValuesL(const TDesC8 &aSectionName, RArray<TPtrC8>& aListBuffer)

{	

	TPtrC8 key;

	TPtrC8 val;

	TInt err = KErrNotFound;	

	Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();

	CleanupStack::PushL(iter);

	//check User configuration file if exists

	//check values for given section in the configuration file 

	//if value exists copy it to array 

	err = iConfigManager->GetSectionValues(aSectionName,*iter);

	if(err == KErrNone)

		{

		TBool found =EFalse;

		while(iter->Next(key,val))

			{

			aListBuffer.AppendL(key);

			aListBuffer.AppendL(val);

			found = ETrue;

			}

		if(!found)

			err = KErrNotFound;

		}

	CleanupStack::PopAndDestroy(); // list

	return err;

}

/**

Sets the Active Filter in the configuration file (primary and secondary filters)

@aCategory filters to be set

@aDupCategory duplicate filters which are not set

@aFilter value that describes primary or secondary filter

@return KErrNone, if successful, otherwise one of the other system-wide

        error codes.

*/

TInt CULoggerServer::SetActiveFilterL(RArray<TUint32> aCategory, TInt aFilterType)

{

	TInt error = KErrNone;

	if(aFilterType == 1)

		{

		if(aCategory.Count()==0 || aCategory.Count()>KMaxPrimaryFiltersLimit)

			error = KErrArgument;

		else

			{

			error = iConfigManager->SetActiveFilter(aCategory,KPrimaryFilterSection);

			if(error == KErrAlreadyExists)

				error = KErrNone;

			}

		}

	if(aFilterType == 2)

		{

		//we don't want to set more secondary filters than KMaxSecondaryFiltersLimit

		RArray<TUint32> tmpArray;

		CleanupClosePushL(tmpArray);

		error = GetActiveFilters(tmpArray, ESecondaryFilter);

		if(!error || error == KErrNotFound)

			{

			error = KErrNone; //in case it was KErrNotFound as it doesn't matter we didn't have any set already

			if(aCategory.Count()==0 ||tmpArray.Count() > KMaxSecondaryFiltersLimit ||

					(tmpArray.Count()+ aCategory.Count()) > KMaxSecondaryFiltersLimit)

				error = KErrArgument;

			}

		CleanupStack::PopAndDestroy(); //tmpArray

		if(!error)

			error = iConfigManager->SetActiveFilter(aCategory,KSecondaryFilterSection);

		}

	return error;

}

/**

Function to remove the Filter from config file

@aFilter  Filter to be removed

@aValue primary or secondary filter to be removed

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::RemoveActiveFilter(RArray<TUint32>& aValue, const TInt aFilter)

{

	TInt ret = KErrNone;

	//remove filter (primary or secondary) from BTrace current configuration

	if(aFilter == EPrimaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxPrimaryFiltersLimit))

		return KErrArgument;

	else if(aFilter == ESecondaryFilter && (aValue.Count()==0 || aValue.Count()>KMaxSecondaryFiltersLimit))

		return KErrArgument;

	ret = iConfigManager->RemoveActiveFilter(aValue,aFilter);

	if(ret == KErrNotFound) //remove operation should succeed in this situation

		ret = KErrNone;

	return ret;

}

/**

Function to set Trace settings to the configuration file

@aValue  value to be set

@aSetting setting to which value to be set

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::SetTraceSettings(const TDesC8&  aValue, const TDesC8& aSetting)

	{

	TInt r = iConfigManager->SetTraceSettings(aValue, aSetting);

	return r;

	}

/**

Function to remove plugin settings from the configuration file

@aPluginName  Plugin name whose settings has to be removed

@return will return KErrNone or else leave with KErrNotFound  

	or any system wide error codes 

*/

TInt CULoggerServer::RemovePluginSettingsL(const TDesC8 &aPluginName)

	{

	if(aPluginName.Length() == 0)

		return KErrArgument;

	TInt ret = KErrNone;

	RArray<TPtrC8> settings;

	ret = GetOptionsSettingsL(aPluginName, settings);

	if(ret != KErrNone || settings.Count()==0)

		ret = KErrNotFound;

	settings.Close();

	if(ret == KErrNone)

		return iConfigManager->RemovePluginSettings(aPluginName);

	else

		return ret;

	}

/**

Resize the BTrace buffer size

@aSize The size to be set for the BTrace buffer.

@return KErrNone, if successful, otherwise one of the other system-wide

        error codes.

*/

TInt CULoggerServer::SetBufferSizeL(TInt aSize)

	{

	if(aSize > KMaxBufferSize || aSize < 1)

		return KErrArgument;

	//get dns to check

	GetBufandDataNotifyValuesL(KDataNotification,iDataNotification);

	if(aSize < iDataNotification)

		return KErrGeneral;

	iBufferSize = aSize;

	HBufC8* Size = HBufC8::NewLC(32);

	Size->Des().Num(iBufferSize);

	CleanupStack::Pop(1);

	TPtr8 ptr(Size->Des());

	TInt r = iConfigManager->SetTraceSettings((const TDesC8&)ptr, KBuffer);

	return r;

	}

/**

Change the mode of the BTrace Buffer

@aValue The mode to be set for the BTrace buffer.

@return KErrNone, if successful, otherwise one of the other system-wide

        error codes.

*/

TInt CULoggerServer::SetBufferMode(const TDesC8& aValue)

	{

	TInt r = SetTraceSettings(aValue, KBufferMode);

	return r;

	}

/**

Resize the Data Notification size

@aSize The size to be set for the Data Notification size.

@return KErrNone, if successful, otherwise one of the other system-wide

        error codes.

*/

TInt CULoggerServer::SetDataNotificationSizeL(TInt aSize)

	{

	if(aSize > KMaxDnsSize || aSize < 0)

		return KErrArgument;

	TInt size, r;

	TRAP_IGNORE((r=GetBufandDataNotifyValuesL(KBuffer,size)));

	if(aSize > size)

		return KErrGeneral;

	iDataNotification = aSize;

	HBufC8* Size = HBufC8::NewLC(32);

	Size->Des().Num(aSize);

	TPtr8 ptr(Size->Des());

	r = SetTraceSettings((const TDesC8&)ptr, KDataNotification);

	CleanupStack::PopAndDestroy();

	return r;

	}

/**

Function to retrieve the Trace Section Values

This should leave with KErrNotFound if cannot find one

as this should be treated as a corrupt config file

*/

void CULoggerServer::GetOptionsSettingsL(RArray<TPtrC8>& aListBuffer,const TDesC8& aSetting)

{

	TPtrC8 key;

	TPtrC8 val;	

	TInt err=0;

	Ulogger::CConfigSettingsIter* iter = Ulogger::CConfigSettingsIter::NewL();

	CleanupStack::PushL(iter);

	err=iConfigManager->GetPluginSettings(*iter);

	if(err==KErrNone)

		{

		while(iter->Next(key,val))

			{

			if(key.Compare(aSetting)==0)

				{

				aListBuffer.AppendL(key);

				aListBuffer.AppendL(val);					

				}

			}

		}

	CleanupStack::PopAndDestroy(); // list

}

/**

Function to retrieve the active primary filters

This should leave with KErrNotFound if cannot find one

as this should be treated as a corrupt config file

*/

TInt CULoggerServer::GetBufandDataNotifyValuesL(const TDesC8& aSetting,TInt& value)

	{

	TInt err = KErrNotFound;

	RArray<TPtrC8> traceValues;

	TFileName filepath;

	GetOptionsSettingsL(traceValues,aSetting);

	value =-1;

	//if values exists for the given trace settings	

	if(traceValues.Count()>1)

		{// get values for buffer mode

		if(aSetting.Compare(KBufferMode)==0)	

			{

			err=KErrNone;

			if(traceValues[1].Compare(KCircular) == 0)

				value = ECircularBuffer;

			else if(traceValues[1].Compare(KStraight) == 0)

				value = EStraightBuffer;

			else

				err=KErrNotFound;

			}

		else

			{// get values for data notification and buffer size

			TLex8 lex_val(traceValues[1]);	

			err = lex_val.Val(value);

			}

		}

	return err;

	}

/**

Set the enable/disable secondary filters

@aSize The size to be set for the BTrace buffer.

@return KErrNone, if successful, otherwise one of the other system-wide

        error codes.

*/

TInt CULoggerServer::SetSecondaryFiltering(const TDesC8& aEnabled)

	{

	TInt error = iConfigManager->SetTraceSettings(aEnabled, KSecondaryGlobalFilter);

	if(error == KErrAlreadyExists)

		error = KErrNone;

	return error;

	}	

/**

Function to retrieve the active primary and secondary filters

This should return KErrNotFound if cannot find one or return any of the system wide error codes

*/

TInt CULoggerServer::GetActiveFilters(RArray<TUint32>& aListBuffer,TInt aFilterType)

	{

	TInt ret = KErrNotFound;

	RArray<TPtrC8> aValues;

	if(aFilterType == 1)

		{

		TRAPD(err, ret = GetValuesL(KPrimaryFilterSection,aValues));

		if (err != KErrNone)

			{

			return err;

			}

		if(ret==KErrNone)	

			{

			TInt i =0;

			TPtrC8 val;	

			TUint8 int_val;

			while(i<aValues.Count())

				{

				TLex8 lex_val(aValues[++i]);	

				ret = lex_val.Val(int_val,EDecimal);	

				if(ret == KErrNone)

					{

					ret = aListBuffer.Append(int_val);

					if (ret != KErrNone)

						{

						return ret;

						}

					}

				else

					{

					return KErrCorrupt;

					}

				i++;		

				}					

			}

		}

	else if(aFilterType == 2)

		{

		TRAPD(err, ret = GetValuesL(KSecondaryFilterSection,aValues));

		if (err != KErrNone)

			{

			return err;

			}

		if(ret==KErrNone)	

			{

			TInt i =0;

			TPtrC8 val;	

			TUint int_val;

			while(i<aValues.Count())

				{

				TLex8 lex_val(aValues[++i]);	

				ret = lex_val.Val(int_val,EDecimal);	

				if(ret == KErrNone)

					{

					ret = aListBuffer.Append(int_val);

					if (ret != KErrNone)

						{

						return ret;

						}

					}

				else

					{

					return KErrCorrupt;

					}

				i++;		

				}					

			}

		else

			{

			if(ret==KErrNotFound)//i.e. if there are no values in the array --> change to if(filters.Count = 0)?

				{

				ret=KErrNone;

				}

			}

		}

	return ret;

	}

/**

Function to retrieve the active secondary global filter

This should leave with KErrNotFound if cannot find one

*/

TInt CULoggerServer::GetSecondaryFiltering(TBool& aEnabled)

{

	RArray<TPtrC8> configSettings;			

	TRAPD(error, GetOptionsSettingsL(configSettings,KSecondaryGlobalFilter));

	if(configSettings[1]==KEnable) //First element contains KSecondaryGlobalFilter, second the value

		aEnabled = ETrue;

	if(configSettings[1]==KDisable)

		aEnabled = EFalse;

	return error; 

}

/**

Function to retrieve the plugin names from the ECOM framework

This should leave with KErrNotFound if cannot find one

*/

TInt CULoggerServer::GetInstalledOutputPlugins(RArray<TPtrC8>& aListBuffer)

	{

	// Read info about all implementations into infoArray

	// Note that a special cleanup function is required to reset and destroy

	// all items in the array, and then close it.

	if(iPluginArray.Count()>0)

	{

     iPluginArray.ResetAndDestroy();

     iPluginArray.Close();

	}

	TRAPD(error,CPluginAllocator::ListAllImplementationsL(iPluginArray));

	if(iPluginArray.Count()>0)

	{

		for (TInt i=0; i< iPluginArray.Count(); i++)

			{

			TRAP(error,aListBuffer.AppendL(iPluginArray[i]->DataType()));

			}

		//filter plugins and to use only output plugins

		FilterPlugins(EOutputPluginFilter, aListBuffer);

	}

	return error;

	}

TInt CULoggerServer::GetInstalledInputPluginsL(RArray<TPtrC8>& aListBuffer)

	{

	#if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)

	__MARK_METHOD("CULoggerServer::GetInstalledControlPlugins")

	#endif

	if(iPluginArray.Count()>0)

		{

	     iPluginArray.ResetAndDestroy();

	     iPluginArray.Close();

		}

	// Read info about all implementations into infoArray

	// Note that a special cleanup function is required to reset and destroy

	// all items in the array, and then close it.

	CPluginAllocator::ListAllImplementationsL(iPluginArray);

	if(iPluginArray.Count() > 0)

		{	

		for (TInt i=0; i< iPluginArray.Count(); i++)

			aListBuffer.AppendL(iPluginArray[i]->DataType());

		//filter plugins and to use only output plugins

		FilterPlugins(EInputPluginFilter, aListBuffer);

		}

	return KErrNone;

	}

/**

Function to retrieve the Active plugin name 

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::GetActiveOutputPlugin(RArray<TPtrC8>& aListBuffer)

	{

	TInt errCode = GetValuesL(KActiveSection,aListBuffer);

	//plugins are received as, e.g. '1 uloggerfileplugin' (.ini file syntax)

	//we have to remove number from array

	for(TInt i=0; i<aListBuffer.Count(); ++i)

		{

		TInt v;

		TLex8 lex(aListBuffer[i]);

		if(lex.Val(v) == KErrNone)

			{

			aListBuffer.Remove(i);

			i=-1; //start from begin, i will be incremented in loop

			}

		}

	return errCode;

	}

/**

Function to Deactivate or remove active output plugin 

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::DeActivateOutputPlugin(const TDesC8 &aPluginname)

{	

	if(iBtraceOpen != EFalse)

		{

		Stop();

		iBtraceOpen = EFalse;

		}

	TInt ret = iConfigManager->DeActivateOutputPlugin(aPluginname);

	return ret;

}

/**

Function to retrieve the Active control plugin name 

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::GetActiveInputPlugin(RArray<TPtrC8>& aListBuffer)

	{

	return GetValuesL(KActiveControlSection,aListBuffer);

	}

/**

Function to Deactivate active control plugin 

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::DeActivateInputPlugin(const TDesC8& aPluginname)

	{

	return iConfigManager->DeActivateInputPlugin(aPluginname);

	}

/**

Function to run ULogger server as service, i.e. to keep it constantly running

(but not necessarily logging) in the background, or to stop it being run as a

service (if EFalse is passed).

@param aRunAsService ETrue to start, EFalse to stop running as service

*/

void CULoggerServer::RunAsService(TBool /*aRunAsService*/)

	{

//

// // Uncomment following to implement run-as-service functionality

//

//	iRunAsService = aRunAsService;

//

//	if (!aRunAsService)

//		{

//		//make sure server is stopped if there are no sessions

//		IncrementSessions();

//		DecrementSessions();

//		}

	}

/**

Function to cd.. ulogger server

This should leave with KErrNotFound if cannot find one or any system wide error codes

*/

TInt CULoggerServer::Start()

	{

	#if defined(__LIGHTLOGGER_ENABLED) && defined(__VERBOSE_MODE)

	__MARK_METHOD("CULoggerServer::Start")

	#endif

	TRAPD(error, InitializeFrameworksL());

	//check errors

	if(error != KErrNone)

		return error;

	if(!iOutputFramework)

		return KErrNotReady;

	if(iBtraceOpen)

		return KErrInUse;

	TPtrC8 key;

	TPtrC8 val;

	TInt buffermode=0;

	RArray<TPtrC8> settings;

	RArray<TUint32> activefilters;

	//checking if there is at least one active channel

	error = GetActiveOutputPlugin(settings);

	if(error != KErrNone)

		return error;

	if(settings.Count()==0)

		{

		return KErrNotFound; //active output plug-in not found

		}

	if(iBtraceOpen == EFalse)

		{

		if(iIsBooting)

			error = TraceSettingsOnBootL();

		else

			error = iTrace.Open();

		if(error == KErrNone)

			{

			//----Reset the notification size

			TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KDataNotification,iDataNotification));

			if(error!=KErrNone)

				return error;

			TRAP_IGNORE(error=GetBufandDataNotifyValuesL(KBuffer,iBufferSize));

			if(error!=KErrNone)

				return error;

			//----Reset BTrace filters

			ResetBtracePrimaryFilters(iTrace);

			//----Resize the trace buffer

			error = iTrace.ResizeBuffer(iBufferSize*1024);

			if(error == KErrNoMemory)

			{

				error = iTrace.ResizeBuffer(KMinBufferMTPLE*1024);

			}

			if(error != KErrNone)

				return error;

			//----Reset the buffer mode

			TRAP_IGNORE(GetBufandDataNotifyValuesL(KBufferMode,buffermode));

			if(buffermode==ECircularBuffer)

			{

				iTrace.SetMode(RBTrace::EFreeRunning|RBTrace::EEnable);	

			}

			else

			{

				iTrace.SetMode(RBTrace::EEnable);

			}

			//----Enable/disable primary filter

			error = GetActiveFilters(activefilters,EPrimaryFilter);

			if(error != KErrNone)

				return error;

			for(TInt i=0; i<activefilters.Count(); ++i)

				{

				TUint filter;

				filter= (TUint8)activefilters[i];

				iTrace.SetFilter(filter,ETrue);

				}

			//----Enable/disable secondary filter

			settings.Reset();

			TBool enabled = EFalse;

			error = GetSecondaryFiltering(enabled);

			if(!error)

				{

				if (enabled)//enable secondary filter, only traces with certain value will pass

					{

					iTrace.SetFilter2(0);

					//enable secondary filters chosen by user

					activefilters.Reset();

					if((error = GetActiveFilters(activefilters,ESecondaryFilter)) == KErrNone)

						for(TInt i=0; i<activefilters.Count(); ++i)

							iTrace.SetFilter2(activefilters[i], ETrue);

					else

						{

						if(error == KErrNotFound)

							{

							error = KErrNone;

							}

						else

							return error;

						}

					}

				else//disable secondary filter, all traces will pass

					{

					iTrace.SetFilter2(1);

					}				

				}

			//set flag to idicate that btrace is open

			iBtraceOpen = ETrue;