1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #include "uloggersysconfig.h"

    18 #include "sysconfigimpl.h"

    19 #include "uloggershared.h"

    20 #include <e32base.h>		 

    21 

    22 

    23 namespace Ulogger

    24 {

    25 	

    26 /** Creates a sysconfig settings iterator object

    27 @return a pointer to the created object

    28 @leave KErrNoMemory if not enough memory available

    29 */

    30 EXPORT_C CConfigSettingsIter* CConfigSettingsIter::NewL()

    31 	{

    32 	CConfigSettingsIter* self=new (ELeave)CConfigSettingsIter();

    33 	CleanupStack::PushL(self);

    34 	self->iImpl=CConfigSettingsImpl::NewL();

    35 	CleanupStack::Pop();

    36 	return self;

    37 	}

    38 

    39 /**

    40 A function to loop through the settings in the system config

    41 and return the setting and its value through the passed in pointer

    42 @param aSetting a pointer to the buffered setting name

    43 @param aSettingValue a pointer to the buffered setting value

    44 @return ETrue if there are more setting

    45         EFalse if the iterator is at end of settings

    46 		Other system wide errors

    47 @post the iterator now points to the next setting

    48 */	

    49 EXPORT_C TBool CConfigSettingsIter::Next(TPtrC8& aSetting,TPtrC8& aSettingValue)

    50 	{

    51 	return iImpl->Next(aSetting,aSettingValue);

    52 	}

    53 

    54 /**

    55 Reset the iterator to point to the first setting

    56 @post the iterator now points to the first setting

    57 */	

    58 EXPORT_C void CConfigSettingsIter::Reset()

    59 	{

    60 	return iImpl->Reset();

    61 	}

    62 

    63 /**

    64 Public Destructor

    65 */	

    66 EXPORT_C CConfigSettingsIter::~CConfigSettingsIter()

    67 	{

    68 	delete iImpl;

    69 	}

    70 

    71 CConfigSettingsIter::CConfigSettingsIter(){}

    72 

    73 ////////////////////////////////////////////////////////////////////////////

    74 

    75 /**

    76 Create a pointer to a CConfig object initialised with the current

    77 configuration settings for the system wide framework.

    78 

    79 Therefore it allocates and manages memory to store these settings.

    80 If the client has a requirement to use a private heap then a reference to it

    81 must be supplied should the notification funtionality be required 

    82 as this will result in the settings being reloaded and hence memory

    83 will need to be reallocated.

    84 Clients with this requirement will need to ensure heaps are switch to ensure

    85 the CConfig object is itself allocated on the correct heap.

    86 

    87 @param aHeap a pointer to a private heap location

    88 @param aFilename name of the configuration file with full path

    89 @return a pointer to the new CConfig object

    90 */

    91 EXPORT_C CConfig* CConfig::NewL(RHeap* aHeap,TFileName& aFilename)

    92 	{

    93 	CConfig* self= new(ELeave) CConfig();

    94 	CleanupStack::PushL(self);

    95 	self->iImpl=CConfigImpl::NewL(aHeap,aFilename);

    96 	CleanupStack::Pop();

    97 	return self;

    98 	}

    99 

   100 /**

   101 Create a pointer to a CConfig object initialised with the current

   102 configuration settings for the system wide framework. Places object

   103 on the Cleanup stack.

   104 

   105 Therefore it allocates and manages memory to store these settings.

   106 If the client has a requirement to use a private heap then a reference to it

   107 must be supplied should the notification funtionality be required 

   108 as this will result in the settings being reloaded and hence memory

   109 will need to be reallocated.

   110 Clients with this requirement will need to ensure heaps are switch to ensure

   111 the CConfig object is itself allocated on the correct heap.

   112 

   113 @param aHeap a pointer to a private heap location

   114 @param aFilename name of the configuration file with full path

   115 @return a pointer to the new CConfig object

   116 */

   117 EXPORT_C CConfig* CConfig::NewLC(RHeap* aHeap,TFileName& aFilename)

   118 	{

   119 	CConfig* self=CConfig::NewL(aHeap,aFilename);

   120 	CleanupStack::PushL(self);

   121 	return self;

   122 	}

   123 

   124 

   125 /**

   126 Create and initialize a setting iterator to the list of output

   127 channels

   128 @param aIter reference to the setting iterator object

   129 @return KErrNone if no error

   130         Other system wide errors

   131 */

   132 EXPORT_C TInt CConfig::GetOutputPlugins(CConfigSettingsIter& aIter)

   133 	{

   134 	return iImpl->GetSection(KActiveSection,aIter);

   135 	}	

   136 

   137 

   138 EXPORT_C TInt CConfig::GetActivePlugins(CConfigSettingsIter& aIter)

   139 	{

   140 	return iImpl->GetSection(KActiveControlSection,aIter);

   141 	}	

   142 

   143 

   144 /**

   145 Create and initialize a setting iterator to the list filters

   146 @param aIter reference to the setting iterator object

   147 @return KErrNone if no error

   148         Other system wide errors

   149 */

   150 EXPORT_C TInt CConfig::GetActiveFilters(CConfigSettingsIter& aIter,TInt aFilter)

   151 	{

   152 	if(aFilter == 1)

   153 		return iImpl->GetSection(KPrimaryFilterSection,aIter);

   154 	else if(aFilter == 2)

   155 		return iImpl->GetSection(KSecondaryFilterSection,aIter);

   156 	else

   157 		return KErrNone;

   158 	}

   159 	

   160 EXPORT_C TInt CConfig::GetSectionValues(const TDesC8& aSectionName,CConfigSettingsIter& aIter)

   161 	{

   162 		return iImpl->GetSection(aSectionName,aIter);

   163 	}	

   164 	

   165 	

   166 /**

   167 Removes output channel setting section from the configuration file

   168 @param aOutputChanId the plugin name which has to be removed

   169 @return KErrNone if no error, 

   170         KErrNotFound if output channel setting section does not exist

   171 		Other System wide errors

   172 */

   173 EXPORT_C TInt CConfig::RemovePluginSettings(const TDesC8& aChanId)

   174 	{

   175 	//

   176 	// NEW CODE:

   177 	//

   178 

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

   180 	CleanupStack::PushL(iter);

   181 

   182 	TInt ret = iImpl->GetSection(aChanId, *iter);

   183 

   184 	if (KErrNone == ret)

   185 		{

   186 		TPtrC8 key;

   187 		TPtrC8 dummy;

   188 

   189 		//remove all keys from section aChanId

   190 		while(iter->Next(key, dummy))

   191 			{

   192 			iImpl->RemoveKey(aChanId, key);

   193 			iter->Reset(); // otherwise we'd be skipping every 2nd element!

   194 			}

   195 

   196 		//remove section

   197 		iImpl->RemoveSection(aChanId);

   198 			//finally write into ini file

   199 			ret = iImpl->PersistIniFile();

   200 		}

   201 

   202 	CleanupStack::PopAndDestroy(iter);

   203 

   204 	return ret;

   205 	}

   206 

   207 /**

   208 Set a particular channel id settings, create one if settings does not exist yet

   209 @param aOutputChanId the channel id

   210 @param aSetting the channel setting to modify or add

   211 @param aValue the value to assign to this setting

   212 @return KErrNone if no error, 

   213         KErrNotFound if no matching output id

   214 		Other System wide errors

   215 */

   216 EXPORT_C TInt CConfig::SetPluginSetting(const TDesC8& aChanId,const TDesC8& aSetting,const TDesC8& aValue)

   217 	{

   218 	TInt ret = iImpl->SetKeyValue(aChanId,aSetting,aValue);

   219 

   220 	if (KErrNone == ret)

   221 		{

   222 		//finally write into ini file

   223 		ret = iImpl->PersistIniFile();

   224 		}

   225 

   226 	return ret;

   227 	}

   228 

   229 /**

   230 Register Active Plugin

   231 An internal active name that maps to this plugin is generated internally

   232 @param aPluginName the plugin to be added to the system.

   233 @param aMediaName pointer to the internal media name

   234 @return KErrNone if no error

   235         KErrAlreadyExists if the plugin name already exists

   236 		Other system wide errors

   237 */

   238 EXPORT_C TInt CConfig::SetActiveOutputPlugin(const TDesC8& aMediaName)

   239 	{

   240 	//first check whether plugin already registered

   241 	TPtrC8 key;

   242 	TPtrC8 val;

   243 	TPtrC8 aMedia;

   244 	

   245 	TInt keyCount=0;

   246 	TInt ret=iImpl->CheckValueExist(KActiveSection,aMediaName,keyCount);

   247 	if(ret == KErrAlreadyExists)

   248 		return ret;

   249 	if ((ret==KErrNone && keyCount))

   250 	{			

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

   252 		CleanupStack::PushL(iter);

   253 		GetOutputPlugins(*iter);

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

   255 		{

   256 			ret=iImpl->RemoveKey(KActiveSection,val);	

   257 		}

   258 		CleanupStack::PopAndDestroy();		

   259 	}

   260 	

   261 	//get the internally generated name

   262 	TBuf8<15> internalName;

   263 	ret=iImpl->GenerateInternalKey(KActiveSection,internalName);

   264 	if (ret!=KErrNone)

   265 		return ret;		

   266 	

   267 	ret=iImpl->SetKeyValue(KActiveSection,internalName,aMediaName);

   268 	if (ret!=KErrNone)

   269 		return ret;

   270 	

   271 	ret= iImpl->GetPointerToKeyName(KActiveSection,internalName,aMedia);

   272 	if (ret!=KErrNone)

   273 		return ret;

   274 	

   275 	//finally write into ini file

   276 	return iImpl->PersistIniFile();

   277 	}

   278 

   279 

   280 EXPORT_C TInt CConfig::SetActiveInputPlugin(const TDesC8& aMediaName)

   281 	{

   282 	//first check whether plugin already registered

   283 	TPtrC8 key;

   284 	TPtrC8 val;

   285 	TPtrC8 aMedia;

   286 	

   287 	TInt keyCount=0;

   288 	TInt ret=iImpl->CheckValueExist(KActiveControlSection,aMediaName,keyCount);

   289 	if(ret == KErrAlreadyExists)

   290 		return ret;

   291 	if ((ret==KErrNone && keyCount))

   292 	{			

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

   294 		CleanupStack::PushL(iter);

   295 		GetActivePlugins(*iter);

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

   297 		{

   298 			ret=iImpl->RemoveKey(KActiveControlSection,val);	

   299 		}

   300 		CleanupStack::PopAndDestroy();		

   301 	}

   302 	

   303 	//get the internally generated name

   304 	TBuf8<15> internalName;

   305 	ret=iImpl->GenerateInternalKey(KActiveControlSection,internalName);

   306 	if (ret!=KErrNone)

   307 		return ret;		

   308 	

   309 	ret=iImpl->SetKeyValue(KActiveControlSection,internalName,aMediaName);

   310 	if (ret!=KErrNone)

   311 		return ret;

   312 	

   313 	ret= iImpl->GetPointerToKeyName(KActiveControlSection,internalName,aMedia);

   314 	if (ret!=KErrNone)

   315 		return ret;

   316 	

   317 	//finally write into ini file

   318 	return iImpl->PersistIniFile();

   319 	}

   320 

   321 

   322 EXPORT_C TInt CConfig::DeActivateOutputPlugin(const TDesC8& aMediaName)

   323 	{

   324 	TPtrC8 key;

   325 	TPtrC8 val;

   326 	TPtrC8 aMedia;

   327 	

   328 	TInt keyCount=0;

   329 	TInt ret=iImpl->CheckValueExist(KActiveSection,aMediaName,keyCount);

   330 	if(ret==KErrNone)

   331 		return KErrNotFound;

   332 	else if (ret==KErrAlreadyExists)

   333 		{			

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

   335 		CleanupStack::PushL(iter);

   336 		User::LeaveIfError(GetOutputPlugins(*iter));

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

   338 			{

   339 			ret=iImpl->RemoveKey(KActiveSection,val);	

   340 			}

   341 		CleanupStack::PopAndDestroy();		

   342 		}

   343 	if(ret!=KErrNone)

   344 		return ret;

   345 	return iImpl->PersistIniFile();

   346 	}

   347 

   348 

   349 EXPORT_C TInt CConfig::DeActivateInputPlugin(const TDesC8& aMediaName)

   350 	{

   351 	TPtrC8 key;

   352 	TPtrC8 val;

   353 	TPtrC8 aMedia;

   354 	

   355 	TInt keyCount=0;

   356 	TInt ret=iImpl->CheckValueExist(KActiveControlSection,aMediaName,keyCount);

   357 	if(ret==KErrNone)

   358 		return KErrNotFound;

   359 	else if (ret==KErrAlreadyExists)

   360 		{			

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

   362 		CleanupStack::PushL(iter);

   363 		TInt a = GetActivePlugins(*iter);

   364 		if(a != KErrNone)

   365 			return a;

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

   367 			{

   368 			ret=iImpl->RemoveKey(KActiveControlSection,val);	

   369 			}

   370 		CleanupStack::PopAndDestroy();		

   371 		}

   372 	if(ret!=KErrNone)

   373 		return ret;

   374 	return iImpl->PersistIniFile();

   375 	}

   376 

   377 

   378 EXPORT_C TInt CConfig::SetActiveFilter(const RArray<TUint32>&  aFilter, const TDesC8 &aSectionName)

   379 {

   380 	TInt error = KErrNone;  

   381 	

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

   383 		{

   384 		//copy the filter as a string

   385 		HBufC8* filter = HBufC8::NewLC(32);

   386 		filter->Des().Num(aFilter[i]);

   387 		TPtr8 filterPtr(filter->Des());

   388 		TInt keycount = 0;

   389 		//check if the section exists

   390 		error = iImpl->CheckValueExist(aSectionName, filterPtr, keycount);

   391 		if (!error)//either the section or the value didn't exist

   392 			{

   393 			TBuf8<15> internalName;

   394 			error = iImpl->GenerateInternalKey(aSectionName, internalName);

   395 			if(!error)

   396 				error = iImpl->SetKeyValue(aSectionName,internalName,filterPtr);

   397 			}

   398 		if(error == KErrAlreadyExists) //ignore these

   399 			error = KErrNone;

   400 		CleanupStack::PopAndDestroy();//filter			

   401 		if(error)

   402 			break;

   403 		}

   404 	//finally write into ini file

   405 	iImpl->PersistIniFile();

   406 	return error; 

   407 }

   408 

   409 EXPORT_C TInt CConfig:: SetTraceSettings(const TDesC8&  aValue, const TDesC8&  aSetting)

   410 {	

   411 	TPtrC8 aMedia;

   412 	TPtrC8 value;

   413 	//get the internally generated name

   414 	

   415 	TInt ret;

   416 	if(aSetting.Compare(KBuffer) == 0)	

   417 	{

   418 		ret=iImpl->SetKeyValue(KTrace,KBuffer,aValue);

   419 		if (ret!=KErrNone)

   420 			return ret;

   421 		

   422 		ret= iImpl->GetPointerToKeyName(KTrace,KBuffer,aMedia);

   423 		if (ret!=KErrNone)

   424 			return ret;	

   425 	}

   426 	else if(aSetting.Compare(KSecondaryGlobalFilter) == 0)		

   427 	{

   428 		iImpl->GetKeyValue(KTrace,KSecondaryGlobalFilter,value);

   429 		if(value.Compare(aValue)==0)

   430 			return KErrNone;

   431 		else

   432 			{

   433 			ret=iImpl->SetKeyValue(KTrace,KSecondaryGlobalFilter,aValue);

   434 			if (ret!=KErrNone)

   435 				return ret;

   436 		

   437 			ret= iImpl->GetPointerToKeyName(KTrace,KSecondaryGlobalFilter,aMedia);

   438 			if (ret!=KErrNone)

   439 				return ret;	

   440 			}

   441 	}

   442 	else if(aSetting.Compare(KDataNotification) == 0)		

   443 	{

   444 		ret=iImpl->SetKeyValue(KTrace,KDataNotification,aValue);

   445 		if (ret!=KErrNone)

   446 			return ret;

   447 		

   448 		ret= iImpl->GetPointerToKeyName(KTrace,KDataNotification,aMedia);

   449 		if (ret!=KErrNone)

   450 			return ret;	

   451 	}

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

   453 	{

   454 		ret=iImpl->SetKeyValue(KTrace,KBufferMode,aValue);

   455 		if (ret!=KErrNone)

   456 			return ret;

   457 		

   458 		ret= iImpl->GetPointerToKeyName(KTrace,KBufferMode,aMedia);

   459 		if (ret!=KErrNone)

   460 			return ret;	

   461 	}

   462 	else 

   463 		return KErrNotFound;

   464 	

   465 	

   466 	//finally write into ini file

   467 	return iImpl->PersistIniFile();

   468 		

   469 }

   470 

   471 

   472 

   473 EXPORT_C TInt CConfig:: GetTraceSettings(CConfigSettingsIter& aIter)

   474 	{

   475 	return iImpl->GetSection(KTrace,aIter);

   476 	}	

   477 

   478 /**

   479 Remove a Filter based on its internal media name. It will fail if

   480 any of this media is still referenced by one of the output channel

   481 @param aMediaName the internal media name of the plugin to be removed

   482 @return KErrNone if no error

   483         KErrNotFound if no matching media name

   484         KErrAccessDenied if still referenced by one of the output channel

   485 */

   486 

   487 EXPORT_C TInt CConfig::RemoveActiveFilter(const RArray<TUint32>&  aFilter, const TInt &aFilterValue)

   488 {

   489 	TPtrC8 sectionName;

   490 	TPtrC8 val;

   491 	TPtrC8 key;

   492 	TInt ret = KErrNotFound;

   493 	

   494 	if(aFilterValue == 1)

   495 		sectionName.Set(KPrimaryFilterSection());

   496 	else if(aFilterValue == 2)

   497 		sectionName.Set(KSecondaryFilterSection());

   498 	

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

   500 	CleanupStack::PushL(iter);

   501 	GetActiveFilters(*iter, aFilterValue);

   502 	

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

   504 		{

   505 		//ret = iImpl->GetSection(aSectionName,iter);

   506 		HBufC8* filter = HBufC8::NewLC(32);

   507 		filter->Des().Num(aFilter[i]);

   508 		TPtr8 ptr(filter->Des());

   509 		CleanupStack::Pop(1);

   510 		

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

   512 		{

   513 			if (key.Compare(ptr)==0)

   514 				{

   515 				TInt tmpRet = iImpl->RemoveKey(sectionName,val);

   516 				if(ret != KErrNone)

   517 					ret = tmpRet;

   518 				break;

   519 				}				

   520 		}

   521 		iter->Reset();	

   522 				

   523 		}

   524 	CleanupStack::PopAndDestroy();	

   525 	//finally write into ini file

   526 	iImpl->PersistIniFile();

   527 	return ret;

   528 		

   529 }

   530 

   531 /**

   532 Public Destructor

   533 */

   534 EXPORT_C CConfig::~CConfig()

   535 	{

   536 	delete iImpl;	

   537 	}

   538 

   539 //default constructor

   540 CConfig::CConfig(){}

   541 

   542 }

   543