1 // Copyright (c) 2008-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 // Contains implementation of CTestUPnPManager class

    15 // Contains implemenatation of CTestUPnPManager, CUPnPObserver, CUPnPTimer, 

    16 // and CAction classes

    17 // 

    18 //

    19 

    20 #include "testupnpmanager.h"

    21 

    22 

    23 /*

    24   Constructor:

    25   @internalTechnology

    26   @test

    27 */

    28 CTestUPnPManager::CTestUPnPManager()

    29 :	CTestStep()

    30 	{

    31 	iCancelDiscovery = EFalse;

    32 	iExpectedData = EFalse;

    33 	iDiscoverySuccess = EFalse;

    34 	iNotifyCount = 0;

    35 	iPublishCount = 0;

    36 	iDescribeResponseCount = 0;

    37 	iRenewCount = 0;

    38 	iFailedNumUris = 0;

    39 	}

    40 

    41 /*

    42    Initializes all member vaiables.

    43    @param		None.

    44    @return		None.

    45 */

    46 void CTestUPnPManager::InitializeL()

    47 	{

    48 	iScheduler = new (ELeave) CActiveScheduler;

    49 	CActiveScheduler::Install(iScheduler);

    50 	

    51 	_LIT(KInfoLogFile, "SequenceOperationsL().... \n");

    52 	INFO_PRINTF1(KInfoLogFile);

    53 	TPtrC listOfSequences;

    54 	_LIT(KListOfSequences, "listofsequences");

    55 	GetStringFromConfig(ConfigSection(), KListOfSequences, listOfSequences);

    56 

    57 	TokenizeStringL(listOfSequences, iSequenceList);

    58 	iNumOperations = iSequenceList.Count();

    59 

    60 	}

    61 

    62 /*

    63    Destructor

    64    @internalTechnology

    65    @test

    66 */

    67 CTestUPnPManager::~CTestUPnPManager()

    68 	{

    69 	}

    70 

    71 void CTestUPnPManager::ClosePublisher()

    72 	{

    73 	_LIT(KInfoLogFile, "ClosePublisher....\n");

    74 	INFO_PRINTF1(KInfoLogFile);

    75 	CancelPublish();

    76 	}

    77 

    78 void CTestUPnPManager::CloseDiscoverer()

    79 	{

    80 	iControlPoint.Close();

    81 	}

    82 

    83 void CTestUPnPManager::CleanUpObserverArray()

    84 	{

    85 	_LIT(KInfoLogFile, "CleanUpObserverArray....\n");

    86 	INFO_PRINTF1(KInfoLogFile);

    87 	if (iObserverArray.Count() > 0 )

    88 		{

    89 		iObserverArray.ResetAndDestroy();

    90 		}

    91 	else

    92 		{

    93 		iObserverArray.Close();

    94 		}

    95 	_LIT(KInfoLogFile1, "CleanUpObserverArray End....\n");

    96 	INFO_PRINTF1(KInfoLogFile1);

    97 	}

    98 

    99 void CTestUPnPManager::CleanUpResultsArray()

   100 	{

   101 	_LIT(KInfoLogFile, "CleanUpResultsArray....\n");

   102 	INFO_PRINTF1(KInfoLogFile);

   103 	TInt count = iResultsArray.Count();

   104 		for (TInt index(0); index < count ; index++ )

   105 			{

   106 			iResultsArray[index]->Close();

   107 			}

   108 	iResultsArray.Close();

   109 	_LIT(KInfoLogFile1, "CleanUpResultsArray End....\n");

   110 	INFO_PRINTF1(KInfoLogFile1);

   111 	}

   112 

   113 void CTestUPnPManager::DescriptionSuiteCleanUp()

   114 	{

   115 	_LIT(KInfoLogFile, "DescriptionSuiteCleanUp....\n");

   116 	INFO_PRINTF1(KInfoLogFile);

   117 	TInt count = iDescriptionSuiteArray.Count();

   118 	for (TInt index(0); index < count ; index++ )

   119 		{

   120 		iDescriptionSuiteArray[index].iBaseUrl.Close();

   121 		iDescriptionSuiteArray[index].iDescription.Close();

   122 		DeleteSeriveUrlsList(index);

   123 		}

   124 	iDescriptionSuiteArray.Close();

   125 	_LIT(KInfoLogFile1, "DescriptionSuiteCleanUp End...\n");

   126 	INFO_PRINTF1(KInfoLogFile1);

   127 	}

   128 

   129 void CTestUPnPManager::ScpdUriArrayCleanUp()

   130 	{

   131 	_LIT(KInfoLogFile, "ScpdUriArrayCleanUp....\n");

   132 	INFO_PRINTF1(KInfoLogFile);

   133 	TInt count = iScpdUriArray.Count();

   134 	for (TInt index(0); index < count ; index++ )

   135 		{

   136 		iScpdUriArray[index].Close();

   137 		}

   138 	iScpdUriArray.Close();

   139 	_LIT(KInfoLogFile1, "ScpdUriArrayCleanUp End....\n");

   140 	INFO_PRINTF1(KInfoLogFile1);

   141 	}

   142 

   143 void CTestUPnPManager::EventUriArrayCleanUp()

   144 	{

   145 	_LIT(KInfoLogFile, "EventUriArrayCleanUp....\n");

   146 	INFO_PRINTF1(KInfoLogFile);

   147 	TInt count = iEventUriArray.Count();

   148 	for (TInt index(0); index < count ; index++ )

   149 		{

   150 		iEventUriArray[index].Close();

   151 		}

   152 	iEventUriArray.Close();

   153 	_LIT(KInfoLogFile1, "EventUriArrayCleanUp End....\n");

   154 	INFO_PRINTF1(KInfoLogFile1);

   155 	}

   156 

   157 void CTestUPnPManager::ControlUriArrayCleanUp()

   158 	{

   159 	_LIT(KInfoLogFile, "ControlUriArrayCleanUp....\n");

   160 	INFO_PRINTF1(KInfoLogFile);

   161 	TInt count = iControlUriArray.Count();

   162 	for (TInt index(0); index < count ; index++ )

   163 		{

   164 		iControlUriArray[index].Close();

   165 		}

   166 	iControlUriArray.Close();

   167 	_LIT(KInfoLogFile1, "ControlUriArrayCleanUp End....\n");

   168 	INFO_PRINTF1(KInfoLogFile1);

   169 	}

   170 

   171 /*

   172    Implementation of CTestStep base class virtual and this is used for doing all

   173    initialisation common

   174     to derived classes here.

   175    @param  None

   176    @return TVerdict

   177  */

   178 TVerdict CTestUPnPManager::doTestStepPreambleL()

   179 	{

   180 	InitializeL();

   181 	SavePreviousLogFileL();

   182 	return CTestStep::doTestStepPreambleL();

   183 	}

   184 

   185 /*

   186  Save the previous log file...if any

   187 */

   188 void CTestUPnPManager::SavePreviousLogFileL()

   189 	{

   190 	_LIT(KInfoLogFile, "Saving Previous logs If any.... \n");

   191 	INFO_PRINTF1(KInfoLogFile);

   192 	RFs fileserv;

   193 	TInt error = fileserv.Connect();

   194 	if(!error)

   195 		{

   196 		_LIT(KlogFile, "C:\\logs\\log.txt");

   197 		_LIT(KPrefixLog, "C:\\upnplogs\\");

   198 		_LIT(KSuffix, "_UDEB");

   199 		_LIT(KExtn, ".txt");

   200 		

   201 		CFileMan* fMan = NULL;

   202 		TRAP_IGNORE(fMan = CFileMan::NewL(fileserv));

   203 		if(fMan != NULL)

   204 			{

   205 			CleanupStack::PushL(fMan);

   206 			RBuf newFileName;

   207 			const TInt KTwentyFour = 24;

   208 			newFileName.Create(ConfigSection().Length() + KTwentyFour );

   209 			newFileName.Copy(KPrefixLog);

   210 			//Script file name

   211 			iScriptName.Copy(ConfigSection());

   212 			newFileName.Append(iScriptName);

   213 			newFileName.Append(KSuffix);

   214 			newFileName.Append(KExtn);

   215 			

   216 			TInt error = fMan->Rename(KlogFile, newFileName);

   217 			if (error != KErrNone)

   218 				{

   219 				_LIT(KErrInfo, "Unable to Save Previous logs...May be NO Previous logs exist \n");

   220 				ERR_PRINTF1(KErrInfo);

   221 				}

   222 			else

   223 				{

   224 				_LIT(KSavingInfo, "<font color=0000ff><b>Saved Previous logs with File Name: <u>%S</u> </b></font> \n");

   225 				INFO_PRINTF2(KSavingInfo, &newFileName);

   226 				}

   227 			CleanupStack::PopAndDestroy(fMan);

   228 			newFileName.Close();

   229 			}

   230 		}

   231 	fileserv.Close();

   232 	_LIT(KInfoLogFile1, "Saving Previous logs End.... \n");

   233 	INFO_PRINTF1(KInfoLogFile1);

   234 	}

   235 

   236 /*

   237  return Script File name..if any

   238 */

   239 const TDesC& CTestUPnPManager::ScriptFileName()

   240 	{

   241 	return iScriptName;

   242 	}

   243 

   244 /*

   245    Implementation of CTestStep base class virtual and it is used for doing all

   246    after test treatment common to derived classes in here.

   247    @return TVerdict

   248  */

   249 TVerdict CTestUPnPManager::doTestStepPostambleL()

   250 	{

   251 		_LIT(KInfoDesctructorBegin, "Begin: In Destructor CTestUpnPanager....\n");

   252 	INFO_PRINTF1(KInfoDesctructorBegin);

   253 	if(iStringPoolMgr)

   254 		{

   255 		iStringPoolMgr->Release();

   256 		//this will tkae care of clean up of iStringPool

   257 		}

   258 	_LIT(KInfoDesctructorBegin2, "Releasing String Pool Manager....\n");

   259 	INFO_PRINTF1(KInfoDesctructorBegin2);

   260 		

   261 	CleanUpObserverArray();

   262 	iDeviceLocationArray.Close();

   263 	CleanUpResultsArray();

   264 	DescriptionSuiteCleanUp();

   265 	ScpdUriArrayCleanUp();

   266 	ControlUriArrayCleanUp();

   267 	EventUriArrayCleanUp();

   268 	CloseDiscoverer();

   269 	//#ifdef _DEBUG

   270 		ClosePublisher();

   271 		CActiveScheduler::Install(NULL); //Testing for ONB hangs

   272 		_LIT(KInfoDesctructorBegin1, "Deleting the Active Schedulers....\n");

   273 		INFO_PRINTF1(KInfoDesctructorBegin1);

   274 		delete iScheduler;

   275 		iScheduler = NULL;	

   276 	//#endif //_Debug

   277 

   278 	iPublisherObserverMap.Close();	

   279 	_LIT(KInfoDesctructorEnd, "End: ....In Destructor CTestUpnPanager\n");

   280 	INFO_PRINTF1(KInfoDesctructorEnd);

   281 

   282 	return CTestStep::doTestStepPostambleL();

   283 	}

   284 

   285 

   286 TVerdict CTestUPnPManager::doTestStepL()

   287 	{

   288 	SequenceOperationsL();

   289 	return TestStepResult();

   290 	}

   291 

   292 /*

   293    This function performs operations based on sequence specified in the ini file

   294    @param  None

   295    @return None

   296 */

   297 void CTestUPnPManager::SequenceOperationsL()

   298 	{

   299 	for(TInt i(0); i < iNumOperations; i++)

   300 		{

   301 		SetCurrentSection(iSequenceList[i]);

   302 		TPtrC operationType;

   303 		_LIT(KOperationType, "operationtype");

   304 		GetStringFromConfig(iSequenceList[i], KOperationType, operationType);

   305 		PerformDesiredOperationsL(iSequenceList[i], operationType);

   306 		}

   307 	}

   308 

   309 /*

   310    This function performs desired operations specified as a parameter

   311    @param  aOperation string representing operation to be performed

   312    @return None

   313 */

   314 void CTestUPnPManager::PerformDesiredOperationsL(const TDesC& aOperation, const TDesC& operationType)

   315 	{

   316 	const TInt KMatch = 0;

   317 //	TPtrC operationType;

   318 //	_LIT(KOperationType, "operationtype");

   319 //	GetStringFromConfig(aOperation, KOperationType, operationType);

   320 	

   321 	if(operationType.Compare(KOpenDiscoverer) == KMatch)

   322 		{

   323 		DoTestOOML(EOpenDiscover);

   324 		}

   325 	else if(operationType.Compare(KDiscovery) == KMatch)

   326 		{

   327 		TPtrC listOfServiceTypes;

   328 		TPtrC listOfMxTimes;

   329 		_LIT(KListOfServiceTypes, "listofservicetypes");

   330 		_LIT(KListOfMxTimes, "listofmxtimes");

   331 		if(!GetStringFromConfig(GetCurrentSection(), KListOfServiceTypes, listOfServiceTypes)

   332 			|| !GetStringFromConfig(GetCurrentSection(), KListOfMxTimes, listOfMxTimes))

   333 			{

   334 			_LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: \n%S, \n%S \n");

   335 			ERR_PRINTF3( KErrInfo, &KListOfServiceTypes, &KListOfMxTimes );

   336 			//SetTestStepResult(EFail);

   337 			return;

   338 			}

   339 		TokenizeStringL(listOfServiceTypes, iServiceTypeList);

   340 		TokenizeStringL(listOfMxTimes, iMxTimeList);

   341 

   342 		DoTestOOML(EDiscover);

   343 		}

   344 	else if(operationType.Compare(KCancelDiscover) == KMatch)

   345 		{

   346 		CancelDiscoverL(aOperation);

   347 		}

   348 	else if(operationType.Compare(KCancelDescribe) == KMatch)

   349 		{

   350 		CancelDescribeL(aOperation);

   351 		}

   352 	else if(operationType.Compare(KPublishService) == KMatch)

   353 		{

   354 		TPtrC iServiceType;

   355 		GetStringFromConfig(aOperation, KServiceType, iServiceType);

   356 

   357 		TPtrC iUsn;

   358 		GetStringFromConfig(aOperation, KUSN, iUsn);

   359 		

   360 		TInt iDuration;

   361 		GetIntFromConfig(aOperation, KCacheControl, iDuration);

   362 		

   363 		TPtrC iDescription;

   364 		GetStringFromConfig(aOperation, KDescription, iDescription);

   365 		

   366 		TPtrC descriptionPath;

   367 		_LIT(KDescriptionPath, "Description_Path");

   368 		GetStringFromConfig(aOperation, KDescriptionPath, iDescriptionPath);

   369 

   370 		DoTestOOML(EPublishService);

   371 //		PublishServiceL(aOperation);

   372 		}

   373 	else if(operationType.Compare(KPublishDevice) == KMatch)

   374 		{

   375 		GetStringFromConfig(aOperation, KParentDeviceUid, iParentdeviceuid);

   376 		GetStringFromConfig(aOperation, KDeviceType, iDevicetype);

   377 		GetStringFromConfig(aOperation, KFriendlyName, iFriendlyname);

   378 		GetStringFromConfig(aOperation, KManufacturer, iManufacturer);

   379 		GetStringFromConfig(aOperation, KManufacturerURL, iManufacturerurl);

   380 		GetStringFromConfig(aOperation, KModelDescription, iModeldescription);

   381 		GetStringFromConfig(aOperation, KModelName, iModelname);

   382 		GetStringFromConfig(aOperation, KModelNumber, iModelnumber);

   383 		GetStringFromConfig(aOperation, KModelURL, iModelurl);

   384 		GetStringFromConfig(aOperation, KPresentationURL, iPresentationurl);

   385 		GetStringFromConfig(aOperation, KSerialNumber, iSerialnumber);

   386 		GetStringFromConfig(aOperation, KUDN, iUdn);

   387 		GetStringFromConfig(aOperation, KUPC, iUpc);

   388 		GetIntFromConfig(aOperation, KCacheControl, iDuration);

   389 		DoTestOOML(EPublishDevice);

   390 		}

   391 	else if(operationType.Compare(KDescribe) == 0)

   392 		{

   393 		DescribeL();

   394 		}

   395 	else if(operationType.Compare(KDescribeService) == 0)

   396 		{

   397 		DescribeServiceL();

   398 		}

   399 	else if(operationType.Compare(KSubscribe) == 0)

   400 		{

   401 		SubscribeForStateChangeNotificationsL();

   402 		}

   403 	else if(operationType.Compare(KUnsubscribe) == 0)

   404 		{

   405 		UnsubscribeForStateChangeNotificationsL(aOperation);

   406 		}

   407 	else if(operationType.Compare(KRegisterAnnouncement) == KMatch)

   408 		{

   409 		RegisterForAnnouncementsL(aOperation);

   410 		}

   411 	else if(operationType.Compare(KCancelNotify) == KMatch)

   412 		{

   413 		CancelNotifyAnnouncementL(aOperation);

   414 		}

   415 	else if(operationType.Compare(KInitiateControl) == KMatch)

   416 		{

   417 		InitiateActionL(aOperation);

   418 		}

   419 	else if(operationType.Compare(KStartScheduler) == KMatch)

   420 		{

   421 		CActiveScheduler::Start();

   422 		}

   423 	else if(operationType.Compare(KStopScheduler) == KMatch)

   424 		{

   425 		CActiveScheduler::Stop();

   426 		}

   427 	else if(operationType.Compare(KStartTimer) == KMatch)

   428 		{

   429 		StartTimerL(aOperation);

   430 		}

   431 	else if(operationType.Compare(KPrintResults) == 0)

   432 		{

   433 		PrintAndValidateResultsL(aOperation);

   434 		}

   435 	}

   436 

   437 /*

   438    Parses a comma separated string and constructs a list out of the values

   439    @param	aString a reference to a string to be tokenized

   440    @param	aList is an out parameter to store a list of tokens in an arry

   441    @param	aSeparator is a character used to delimit the tokens

   442   */

   443 void CTestUPnPManager::TokenizeStringL(const TDesC& aString, RArray<TPtrC>& aList, TChar aSeparator)

   444 	{

   445 	TLex lexer(aString);

   446 

   447 	while(!lexer.Eos())

   448 		{

   449 		lexer.SkipSpaceAndMark();

   450 

   451 		while(!lexer.Eos() && lexer.Get() != aSeparator)

   452 			{

   453 			}

   454 

   455 		if(!lexer.Eos())

   456 			{

   457 			lexer.UnGet();

   458 			}

   459 		aList.AppendL(lexer.MarkedToken());

   460 		lexer.Inc();

   461 		}

   462 	}

   463 

   464 /*

   465    Starts a timer for a wait time and triggers CallBack function as timer expires.

   466    @param	None

   467    @return	None

   468  */

   469 void CTestUPnPManager::StartTimerL(const TDesC& aOperationType)

   470 	{

   471 	_LIT(KInfoLogFile, "StartTimerL.... \n");

   472 	INFO_PRINTF1(KInfoLogFile);

   473 	_LIT(KWaitTime,"waittime");

   474 	TInt waitTime = 0;

   475 	GetIntFromConfig(aOperationType, KWaitTime, waitTime);

   476 //	TTimeIntervalMicroSeconds32 interval(waitTime);

   477 	CUPnPTimer* timer = CUPnPTimer::NewL(this);

   478 	CleanupStack::PushL(timer);

   479 	timer->IssueRequestL(waitTime);

   480 	CActiveScheduler::Start();

   481 	CleanupStack::PopAndDestroy(timer);

   482 	_LIT(KInfoLogFile1, "StartTimerL End.... \n");

   483 	INFO_PRINTF1(KInfoLogFile1);

   484 	}

   485 

   486 /*

   487    Sets the current config section.

   488    @param	aCurrentSection - a reference string that represent current config section

   489    @return	None

   490  */

   491 void CTestUPnPManager::SetCurrentSection(const TDesC& aCurrentSection)

   492 	{

   493 	iCurrentSection = aCurrentSection;

   494 	}

   495 

   496 /*

   497    Retrieve the current config section.

   498    @param

   499    @return	Reference to current config section

   500  */

   501 TDesC& CTestUPnPManager::GetCurrentSection()

   502 	{

   503 	return	iCurrentSection;

   504 	}

   505 

   506 /*

   507 	Tests whether discovering services/devices is performing as specified in UPnP specifications.

   508 	@param		aOperationType is reference to a section name in ini file where required parameters

   509 				needs to be referred for this operation.

   510 	@return		None.

   511  */

   512 void CTestUPnPManager::DiscoverL()

   513 	{

   514 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

   515 	iObserverArray.AppendL(upnpObserver);

   516 	CPnPParameterBundle* pnpBundle = CPnPParameterBundle::NewL( );

   517 	CleanupClosePushL( *pnpBundle );

   518 	pnpBundle->SetPnPObserver((MPnPObserver*)upnpObserver);

   519 

   520 	CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL ( *pnpBundle , EUPnPDiscoverRequestParamSet );

   521 	TInt numUris = iServiceTypeList.Count();

   522 	iFailedNumUris = iServiceTypeList.Count(); //This should be of Unique Uri's count

   523 	TInt numMxs = iMxTimeList.Count();

   524 	TLex responseTimeObj;

   525 	RBuf8 buf;

   526 	buf.CreateL(KMaxUriSize);

   527 	for(TInt i(0); i < numUris; i++)

   528 		{

   529 		CUPnPDiscoverRequestParamSet* discoverParamSet = CUPnPDiscoverRequestParamSet::NewL(pnpFamily );

   530 		buf.Copy(iServiceTypeList[i]);

   531 		discoverParamSet->SetUriL( buf );

   532 		//response time

   533 		responseTimeObj.Assign(iMxTimeList[i]);

   534 		TInt responseTime(0);

   535 		responseTimeObj.Val(responseTime);

   536 		discoverParamSet->SetResponseTime(responseTime);

   537 		}

   538 	iControlPoint.Discover(*pnpBundle);

   539 	CActiveScheduler::Start();

   540 

   541 	buf.Close();

   542 	iMxTimeList.Close();

   543 	iServiceTypeList.Close();

   544 	CleanupStack::PopAndDestroy( pnpBundle );

   545 	}

   546 

   547 TBool CTestUPnPManager::IsDiscoverySuccess()

   548 	{

   549 	return iDiscoverySuccess;

   550 	}

   551 

   552 void CTestUPnPManager::SetDiscoveryStatus(TBool aSuccess)

   553 	{

   554 	_LIT(KInfoDiscoverSetStatus, "Setting iDiscoverySuccesss Flag to %d \n");

   555 	INFO_PRINTF2(KInfoDiscoverSetStatus, aSuccess );

   556 	iDiscoverySuccess = aSuccess;

   557 	}

   558 

   559 /*

   560 	Tests whether Publishing a Service/Device is performing as specified in UPnP specifications.

   561 	@param			aOperationType is reference to a section name in ini file where required parameters

   562 					needs to be referred for this operation.

   563 	@return			None.

   564  */

   565 void CTestUPnPManager::PublishServiceL ()

   566 	{

   567 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

   568 	iObserverArray.Append(upnpObserver);

   569 	//To keep track of mapping between Observer and Publisher

   570 	TInt observerIndex = iObserverArray.Count() - 1;

   571 	CPnPParameterBundle* pnpBundle = CPnPParameterBundle::NewL( );

   572     CleanupClosePushL( *pnpBundle );

   573     pnpBundle->SetPnPObserver((MPnPObserver*)upnpObserver);

   574 	CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL (*pnpBundle , EUPnPServiceRegisterParamSet );

   575    	CUPnPServiceRegisterParamSet* registerServiceParamSet = CUPnPServiceRegisterParamSet::NewL(pnpFamily );

   576 	RBuf8 serviceTypeBuf;

   577 	serviceTypeBuf.Create(iServiceType.Length());

   578 	serviceTypeBuf.Copy(iServiceType);

   579 

   580 	RBuf8 usnBuf;

   581 	usnBuf.Create(iUsn.Length());

   582 	usnBuf.Copy(iUsn);

   583 

   584 	RBuf8 descriptionBuf;

   585 	descriptionBuf.Create(iDescription.Length());

   586 	descriptionBuf.Copy(iDescription);

   587 

   588 	registerServiceParamSet->SetUriL ( serviceTypeBuf );

   589 	registerServiceParamSet->SetDeviceUidL ( usnBuf );

   590 	registerServiceParamSet->SetCacheControlData ( iDuration );

   591 	registerServiceParamSet->SetSubscriptionDuration(300);

   592 	

   593 	ExtractServiceDescriptionL (*registerServiceParamSet);

   594 

   595 	_LIT8(KInitialMessage, "Initial Service Message");

   596 	registerServiceParamSet->SetInitialMessageL(KInitialMessage);

   597 

   598 	//To keep track of mapping between Observer and Publisher

   599 	TInt publisherIndex = OpenPublisherL();

   600 	//Create mapping of Publsiher and observer

   601 	TPublisherObserverMap publisherObserverMapElement;

   602 	publisherObserverMapElement.iPublisherIndex = publisherIndex;

   603 	publisherObserverMapElement.iObserverIndex =  observerIndex;

   604 	publisherObserverMapElement.iPublisherControl = KService;

   605 	iPublisherObserverMap.Append(publisherObserverMapElement);

   606 

   607 	//Publish service nad update publish count

   608 	iPublishCount++;

   609 	iPublisherArray[publisherIndex].Publish(*pnpBundle);

   610 

   611 	descriptionBuf.Close();

   612 	usnBuf.Close();

   613 	serviceTypeBuf.Close();

   614 	CleanupStack::PopAndDestroy( pnpBundle );

   615 	}

   616 	

   617 /*

   618  * Get publisher mapping index for the given observer index

   619  */

   620 TInt CTestUPnPManager::GetPublisherIndex (TInt aObserverIndex)

   621 	{

   622 	_LIT(KInfoLogFile, "GetPublisherIndex.... \n");

   623 	INFO_PRINTF1(KInfoLogFile);

   624 	

   625 	TInt count = iPublisherObserverMap.Count();

   626 	for (TInt index(0); index < count ; index++ )

   627 		{

   628 		if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)

   629 			{

   630 			return iPublisherObserverMap[index].iPublisherIndex;

   631 			}

   632 		}

   633 	return KErrNotFound;

   634 	}

   635 

   636 /*

   637  * Gets publisher control i.e, Device/Service for the given observer index

   638  */

   639 TPublisherControl CTestUPnPManager::GetPublisherControl (TInt aObserverIndex)

   640 	{

   641 	_LIT(KInfoLogFile, "GetPublisherControl.... \n");

   642 	INFO_PRINTF1(KInfoLogFile);

   643 	

   644 	TInt count = iPublisherObserverMap.Count();

   645 	for (TInt index(0); index < count ; index++ )

   646 		{

   647 		if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)

   648 			{

   649 			return iPublisherObserverMap[index].iPublisherControl;

   650 			}

   651 		}

   652 	return KErrNoControl;

   653 	}

   654 

   655 /*

   656  * Gets publisher control i.e, Device/Service for the given observer index

   657  */

   658 TPublisherControl CTestUPnPManager::PublisherType (TInt aPublisherIndex)

   659 	{

   660 	_LIT(KInfoLogFile, "PublisherType.... \n");

   661 	INFO_PRINTF1(KInfoLogFile);

   662 	TInt count = iPublisherObserverMap.Count();

   663 	TPublisherControl publisherControl = KErrNoControl;

   664 	for (TInt index(0); index < count ; index++ )

   665 		{

   666 		if (iPublisherObserverMap[index].iPublisherIndex == aPublisherIndex)

   667 			{

   668 			switch (iPublisherObserverMap[index].iPublisherControl)

   669 				{

   670 				case KService:

   671 					{

   672 					publisherControl = KService;

   673 					break;

   674 					}

   675 				case KDevice:

   676 					{

   677 					publisherControl = KDevice;

   678 					break;

   679 					}

   680 				default :

   681 					{

   682 					publisherControl = KErrNoControl;

   683 					break;

   684 					}

   685 				}

   686 			}

   687 		}

   688 	_LIT(KInfoLogFile2, "PublisherType....End \n");

   689 	INFO_PRINTF1(KInfoLogFile2);

   690 	return publisherControl;

   691 	}

   692 

   693 TInt CTestUPnPManager::NotifyCount()

   694 	{

   695 	return iNotifyCount;

   696 	}

   697 

   698 TBool CTestUPnPManager::SendNotificationsL (CUPnPObserver* aObserver)

   699 	{

   700 	_LIT(KInfoLogFile, "SendNotificationsL.... \n");

   701 	INFO_PRINTF1(KInfoLogFile);

   702 	

   703     TInt observerIndex = iObserverArray.Find(aObserver);

   704     TInt publisherIndex = GetPublisherIndex(observerIndex);

   705     TPublisherControl publisherControl = GetPublisherControl(observerIndex);

   706 

   707     if(publisherControl != KService)

   708     	{

   709     	_LIT(KSendNotifyErr,"SEND NOTIFY NOT EXECUTED -- Can be Executed only ON Services...\n");

   710     	ERR_PRINTF1(KSendNotifyErr);

   711     	return EFalse;

   712     	}

   713 

   714     CPnPParameterBundle* pnpBundle = CPnPParameterBundle ::NewL( );

   715     CleanupClosePushL( *pnpBundle );

   716 	pnpBundle->SetPnPObserver((MPnPObserver*)this);

   717 

   718     CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL (*pnpBundle , EUPnPServiceNotificationParamSet);

   719     CUPnPServiceNotificationParamSet* ServiceNotifyParamSet = CUPnPServiceNotificationParamSet::NewL (pnpFamily );

   720 

   721 	RBuf8 notificationDataBuf;

   722 	notificationDataBuf.CreateL(_L8("notification"));

   723 

   724 	ServiceNotifyParamSet->SetNotificationL (notificationDataBuf );

   725 	iNotifyCount++;

   726 	if(publisherIndex >= 0)

   727 		{

   728 		iPublisherArray[publisherIndex].SendNotify(*pnpBundle );

   729 		_LIT(KSendNotify,"Info: SEND NOTIFY SUCCESSFUL...\n");

   730 		INFO_PRINTF1(KSendNotify);

   731 		}

   732 	else

   733 		{

   734 		_LIT(KSendNotifyFailed,"Err: SEND NOTIFY UNSUCCESSFUL...\n");

   735 		ERR_PRINTF1(KSendNotifyFailed);

   736 		}

   737 

   738 	CleanupStack::PopAndDestroy( pnpBundle );

   739 	notificationDataBuf.Close();

   740 	_LIT(KInfoLogFile1, "SendNotificationsL End.... \n");

   741 	INFO_PRINTF1(KInfoLogFile1);

   742 	

   743 	return ETrue;

   744 	}

   745 

   746 /*

   747 	Extract service description available in a file, copy it to the buffer and append the same to service register paramset.

   748 	@param			aConfigSection - reference to a section name in ini file where required parameters that needs to be referred for this operation.

   749 					aServiceRegisterParamSet - Storage for the description buffer

   750 	@return			None.

   751  */

   752 

   753 void CTestUPnPManager::ExtractServiceDescriptionL (CUPnPServiceRegisterParamSet& aServiceRegisterParamSet)

   754 	{

   755 	if((iDescriptionPath == KNullDesC) && (iDescription == KNullDesC)) 

   756 		{

   757 		_LIT8(KDefaultServiceDescription, "defaultservicedescription");

   758 		TBuf8<KMaxBufLength> descBuf;

   759 		descBuf.Copy(KDefaultServiceDescription);

   760 		aServiceRegisterParamSet.SetServiceDescriptionL (descBuf);

   761 		return;

   762 		}

   763 	else

   764 		{

   765 		RFs fs;

   766 		RFile file;

   767 		TInt err;

   768 		RBuf8 buf;

   769 		User::LeaveIfError(fs.Connect());

   770 		CleanupClosePushL(fs);

   771 		if(iDescriptionPath != KNullDesC)

   772 			{

   773 			err = file.Open(fs, iDescriptionPath, EFileShareReadersOnly);

   774 			}

   775 		else 

   776 			{

   777 			err = file.Open(fs, iDescription, EFileShareReadersOnly);

   778 			}

   779 

   780 		if (err != KErrNone)

   781 			{

   782 			User::LeaveIfError(err);

   783 			}

   784 		CleanupClosePushL(file);

   785 		TInt fileSize = 0;

   786 		file.Size(fileSize);

   787 		buf.Create(fileSize);

   788 		err = file.Read(buf, fileSize);

   789 		aServiceRegisterParamSet.SetServiceDescriptionL ( buf );

   790 		_LIT(KServiceDescription, "ServiceDescription is.... %S \n");

   791 		INFO_PRINTF2(KServiceDescription, &buf);

   792 		CleanupStack::PopAndDestroy(2);

   793 		buf.Close();

   794 		}

   795 	_LIT(KInfoLogFile1, "ExtractServiceDescriptionL() End.... \n");

   796 	INFO_PRINTF1(KInfoLogFile1);

   797 	}

   798 

   799 void CTestUPnPManager::ResolveScpdUrisL(TInt aIndex)

   800 	{

   801 	_LIT(KInfoLogFile, "ResolveScpdUrisL .... \n");

   802 	INFO_PRINTF1(KInfoLogFile);

   803 	if ( aIndex < 0 )

   804 		{

   805 		_LIT(KBadIndex, "BadIndex...ResolveScpdUrisL Cannot be executed \n");

   806 		ERR_PRINTF1(KBadIndex);

   807 		return;

   808 		}

   809 	const TInt KSlashLenghth = 1;

   810 	TUriParser8 uri;

   811 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

   812 	TBuf8<KMaxUriSize> buf;

   813 	buf.Copy(uri.Extract(EUriScheme));

   814 

   815 	buf.Append(KColonSlashSlash);

   816 	buf.Append(uri.Extract(EUriHost));

   817 

   818 	buf.Append(KColon);

   819 	buf.Append(uri.Extract(EUriPort));

   820 

   821 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

   822 	for (TInt scpdIndex(0); scpdIndex < count; scpdIndex++ )

   823 		{

   824 		RBuf8 scpdUri;

   825 		scpdUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Length());

   826 		scpdUri.Copy(buf);

   827 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Find(KSlash)!=0)

   828 			 {

   829 			 scpdUri.Append(KSlash);

   830 			 }

   831 		 scpdUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl);

   832 		 AppendScpdUriL(scpdUri);

   833 		}

   834 	_LIT(KInfoLogFile1, "ResolveScpdUrisL End .... \n");

   835 	INFO_PRINTF1(KInfoLogFile1);

   836 	}

   837 

   838 void CTestUPnPManager::ResolveEventUrisL(TInt aIndex)

   839 	{

   840 	_LIT(KInfoLogFile, "ResolveEventUrisL.... \n");

   841 	INFO_PRINTF1(KInfoLogFile);

   842 	if ( aIndex < 0 )

   843 		{

   844 		_LIT(KBadIndex, "BadIndex...ResolveEventUrisL Cannot be executed \n");

   845 		ERR_PRINTF1(KBadIndex);

   846 		return;

   847 		}

   848 	const TInt KSlashLenghth = 1;

   849 	TUriParser8 uri;

   850 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

   851 	TBuf8<KMaxUriSize> buf;

   852 	buf.Copy(uri.Extract(EUriScheme));

   853 

   854 	buf.Append(KColonSlashSlash);

   855 	buf.Append(uri.Extract(EUriHost));

   856 

   857 	buf.Append(KColon);

   858 	buf.Append(uri.Extract(EUriPort));

   859 

   860 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

   861 	for (TInt eventIndex(0); eventIndex < count; eventIndex++ )

   862 		{

   863 		RBuf8 eventUri;

   864 		eventUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Length());

   865 		eventUri.Copy(buf);

   866 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Find(KSlash)!=0)

   867 			 {

   868 			 eventUri.Append(KSlash);

   869 			 }

   870 		 eventUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl);

   871 		 AppendEventUriL(eventUri);

   872 		}

   873 	_LIT(KInfoLogFile1, "ResolveEventUrisL End.... \n"); 

   874 	INFO_PRINTF1(KInfoLogFile1);

   875 		

   876 	}

   877 

   878 void CTestUPnPManager::ResolveControlUrisL(TInt aIndex)

   879 	{

   880 	_LIT(KInfoLogFile, "ResolveControlUrisL().... \n");

   881 	INFO_PRINTF1(KInfoLogFile);

   882 	if ( aIndex < 0 )

   883 		{

   884 		_LIT(KBadIndex, "BadIndex...ResolveControlUrisL Cannot be executed \n");

   885 		ERR_PRINTF1(KBadIndex);

   886 		return;

   887 		}

   888 	const TInt KSlashLenghth = 1;

   889 	TUriParser8 uri;

   890 	uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);

   891 	TBuf8<KMaxUriSize> buf;

   892 	buf.Copy(uri.Extract(EUriScheme));

   893 

   894 	buf.Append(KColonSlashSlash);

   895 	buf.Append(uri.Extract(EUriHost));

   896 

   897 	buf.Append(KColon);

   898 	buf.Append(uri.Extract(EUriPort));

   899 

   900 	TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();

   901 	for (TInt ControlIndex(0); ControlIndex < count; ControlIndex++ )

   902 		{

   903 		RBuf8 controlUri;

   904 		controlUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Length());

   905 		controlUri.Copy(buf);

   906 		 if (iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Find(KSlash)!=0)

   907 			 {

   908 			 controlUri.Append(KSlash);

   909 			 }

   910 		 controlUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl);

   911 		 AppendControlUriL(controlUri);

   912 		}

   913 	_LIT(KInfoLogFile1, "ResolveControlUrisL() End.... \n");

   914 	INFO_PRINTF1(KInfoLogFile1);

   915 	}

   916 

   917 /*

   918 	Opens a handle to a RPnPServiceDiscovery object

   919 	@param			None.

   920 	@return			None.

   921  */

   922 void CTestUPnPManager::OpenDiscovererL()

   923 	{

   924 	User::LeaveIfError(iControlPoint.Open(KTierId));

   925 	}

   926 

   927 /*

   928 	Opens a handle to a RPnPServicePublisher object and append the same to Publisher array

   929 	@param			None.

   930 	@return			TBool representing success or failure of the operation.

   931  */

   932 TInt CTestUPnPManager::OpenPublisherL()

   933 	{

   934   	RPnPServicePublisher publisher;

   935 	TInt openStatus = 0;

   936 	User::LeaveIfError(publisher.Open(KTierId));

   937 	iPublisherArray.AppendL(publisher);

   938 	TInt index = iPublisherArray.Count() - 1;

   939 	return index;

   940 	}

   941 	

   942 /*

   943 	Publishing of device as per UPnP specifications.

   944 	@param			aOperationType is reference to a section name in ini file where required parameters

   945 					needs to be referred for this operation.

   946 	@return			None.

   947  */

   948 

   949 void CTestUPnPManager::PublishDeviceL ()

   950 	{

   951 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

   952 	iObserverArray.AppendL(upnpObserver);

   953 

   954 	//To keep track of mapping between Observer and Publisher

   955 	TInt observerIndex = iObserverArray.Count() - 1;

   956 

   957 	CPnPParameterBundle* pnpBundle = CPnPParameterBundle::NewL( );

   958     CleanupClosePushL( *pnpBundle );

   959 	pnpBundle->SetPnPObserver((MPnPObserver*)upnpObserver);

   960 	CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL (*pnpBundle , EUPnPDeviceRegisterParamSet );

   961 	CUPnPDeviceRegisterParamSet* registerDeviceParamSet = CUPnPDeviceRegisterParamSet::NewL(pnpFamily );

   962 

   963 	RBuf8 parentdeviceuidBuf;

   964 	parentdeviceuidBuf.CreateL(iParentdeviceuid.Length());

   965 	parentdeviceuidBuf.Copy(iParentdeviceuid);

   966 

   967 	RBuf8 devicetypeBuf;

   968 	devicetypeBuf.CreateL(iDevicetype.Length());

   969 	devicetypeBuf.Copy(iDevicetype);

   970 

   971 	RBuf8 friendlynameBuf;

   972 	friendlynameBuf.CreateL(iFriendlyname.Length());

   973 	friendlynameBuf.Copy(iFriendlyname);

   974 

   975 	RBuf8 manufacturerBuf;

   976 	manufacturerBuf.CreateL(iManufacturer.Length());

   977 	manufacturerBuf.Copy(iManufacturer);

   978 

   979 	RBuf8 manufacturerurlBuf;

   980 	manufacturerurlBuf.CreateL(iManufacturerurl.Length());

   981 	manufacturerurlBuf.Copy(iManufacturerurl);

   982 

   983 	RBuf8 modeldescriptionBuf;

   984 	modeldescriptionBuf.CreateL(iModeldescription.Length());

   985 	modeldescriptionBuf.Copy(iModeldescription);

   986 

   987 	RBuf8 modelnameBuf;

   988 	modelnameBuf.CreateL(iModelname.Length());

   989 	modelnameBuf.Copy(iModelname);

   990 

   991 	RBuf8 modelnumberBuf;

   992 	modelnumberBuf.CreateL(iModelnumber.Length());

   993 	modelnumberBuf.Copy(iModelnumber);

   994 

   995 

   996 	RBuf8 modelurlBuf;

   997 	modelurlBuf.CreateL(iModelurl.Length());

   998 	modelurlBuf.Copy(iModelurl);

   999 

  1000 	RBuf8 presentationurlBuf;

  1001 	presentationurlBuf.CreateL(iPresentationurl.Length());

  1002 	presentationurlBuf.Copy(iPresentationurl);

  1003 

  1004 	RBuf8 serialnumberBuf;

  1005 	serialnumberBuf.CreateL(iSerialnumber.Length());

  1006 	serialnumberBuf.Copy(iSerialnumber);

  1007 

  1008 	RBuf8 udnBuf;

  1009 	udnBuf.CreateL(iUdn.Length());

  1010 	udnBuf.Copy(iUdn);

  1011 

  1012 	RBuf8 upcBuf;

  1013 	upcBuf.CreateL(iUpc.Length());

  1014 	upcBuf.Copy(iUpc);

  1015 

  1016 

  1017 	TInt publisherIndex = OpenPublisherL();

  1018 	registerDeviceParamSet-> SetParentDeviceUidL(parentdeviceuidBuf);

  1019 	registerDeviceParamSet-> SetUriL (devicetypeBuf);

  1020 	registerDeviceParamSet-> SetFriendlyNameL (friendlynameBuf);

  1021 	registerDeviceParamSet-> SetManufacturerL (manufacturerBuf );

  1022 	registerDeviceParamSet-> SetManufactureUrlL (manufacturerurlBuf);

  1023 	registerDeviceParamSet-> SetModelDescL (modeldescriptionBuf);

  1024 	registerDeviceParamSet-> SetModelNameL (modelnameBuf);

  1025 	registerDeviceParamSet-> SetModelNumberL (modelnumberBuf);

  1026 	registerDeviceParamSet-> SetModelUriL (modelurlBuf);

  1027 	registerDeviceParamSet-> SetPresentationL (presentationurlBuf);

  1028 	registerDeviceParamSet-> SetUDNL (udnBuf);

  1029 	registerDeviceParamSet-> SetUPCL (upcBuf);

  1030 	registerDeviceParamSet-> SetCacheControlData (iDuration);

  1031 	registerDeviceParamSet-> SetSerialNumberL (serialnumberBuf);

  1032 

  1033 	//To keep track of mapping between Observer and Publisher

  1034 	//Create mapping of Publsiher and observer

  1035 	TPublisherObserverMap publisherObserverMapElement;

  1036 	publisherObserverMapElement.iPublisherIndex = publisherIndex;

  1037 	publisherObserverMapElement.iObserverIndex =  observerIndex;

  1038 	publisherObserverMapElement.iPublisherControl = KDevice;

  1039 	iPublisherObserverMap.AppendL(publisherObserverMapElement);

  1040 

  1041 	//Publish Device and update publish count

  1042 	iPublishCount++;

  1043 	iPublisherArray[publisherIndex].Publish(*pnpBundle);

  1044 

  1045 	CleanUpObserverArray();

  1046 	upcBuf.Close();

  1047 	udnBuf.Close();

  1048 	serialnumberBuf.Close();

  1049 	presentationurlBuf.Close();

  1050 	modelurlBuf.Close();

  1051 	modelnumberBuf.Close();

  1052 	modelnameBuf.Close();

  1053 	manufacturerurlBuf.Close();

  1054 	manufacturerBuf.Close();

  1055 	friendlynameBuf.Close();

  1056 	devicetypeBuf.Close();

  1057 	parentdeviceuidBuf.Close();

  1058 	CleanupStack::PopAndDestroy( pnpBundle );

  1059 	_LIT(KInfoLogFile1, "PublishDeviceL End.... \n");

  1060 	INFO_PRINTF1(KInfoLogFile1);

  1061 	}

  1062 

  1063 /*

  1064 Test for Register announcements ssdp:alive and ssdp:byebye messages

  1065 	@param			aOperationType is reference to a section name in ini file where required parameters

  1066 					needs to be referred for this operation.

  1067 	@return			None.

  1068 */

  1069 void  CTestUPnPManager::RegisterForAnnouncementsL (const TDesC& aOperationType)

  1070 	{

  1071 	_LIT(KInfoLogFile, "RegisterForAnnouncementsL().... \n");

  1072 	INFO_PRINTF1(KInfoLogFile);

  1073 	RArray<TPtrC> uriTypeList;

  1074 	TPtrC listOfUriTypes;

  1075 	_LIT(KListOfUriTypes, "listofuritypes");

  1076 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

  1077 	iObserverArray.Append(upnpObserver);

  1078 	CPnPParameterBundle* pnpBundle = CPnPParameterBundle::NewL( );

  1079 	CleanupClosePushL( *pnpBundle );

  1080 	pnpBundle->SetPnPObserver((MPnPObserver*)upnpObserver);

  1081 

  1082 	CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL ( *pnpBundle , EUPnPRegisterAnnouncementParamSet );

  1083 	if(!GetStringFromConfig(GetCurrentSection(), KListOfUriTypes, listOfUriTypes))

  1084 		{

  1085 		_LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: \n%S, \n%S \n");

  1086 		ERR_PRINTF2( KErrInfo, &KListOfUriTypes);

  1087 		return;

  1088 		}

  1089 

  1090 	TokenizeStringL(listOfUriTypes, uriTypeList);

  1091 	TInt numUris = uriTypeList.Count();

  1092 	RBuf8 buf;

  1093 	buf.Create(KMaxUriSize);

  1094 	for(TInt i(0); i < numUris; i++)

  1095 		{

  1096 		CUPnPRegisterAnnouncementParamSet* announcementParamSet = CUPnPRegisterAnnouncementParamSet::NewL(pnpFamily );

  1097 		buf.Copy(uriTypeList[i]);

  1098 		announcementParamSet->SetUriL( buf );

  1099 		}

  1100 	buf.Close();

  1101 	uriTypeList.Close();

  1102 	iControlPoint.RegisterNotify(*pnpBundle );

  1103 	TBool schedulerStart = EFalse;

  1104 	_LIT(KSchedulerStart, "schedulerstart");

  1105 	GetBoolFromConfig(aOperationType, KSchedulerStart, schedulerStart);

  1106 	if(schedulerStart)

  1107 		{

  1108 		CActiveScheduler::Start();

  1109 		}

  1110 	CleanupStack::PopAndDestroy(pnpBundle);

  1111 	_LIT(KInfoLogFile1, "RegisterForAnnouncementsL() End.... \n");

  1112 	INFO_PRINTF1(KInfoLogFile1);

  1113 	

  1114 	

  1115 	}

  1116 

  1117 /*

  1118 	Tests whether subscribtion to event change notifications is performing as specified in UPnP specifications.

  1119 	@param			None.

  1120 	@return			None.

  1121  */

  1122 void  CTestUPnPManager::SubscribeForStateChangeNotificationsL()

  1123 	{

  1124 	_LIT(KInfoLogFile, "SubscribeForStateChangeNotificationsL() start.... \n");

  1125 	INFO_PRINTF1(KInfoLogFile);

  1126 	CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);

  1127 	CleanupStack::PushL( upnpObserver );

  1128 	CPnPParameterBundle* pnpBundle = CPnPParameterBundle::NewL( );

  1129     CleanupClosePushL( *pnpBundle );

  1130 	pnpBundle->SetPnPObserver((MPnPObserver*)upnpObserver);

  1131 	CUPnPParameterFamily* pnpFamily = CUPnPParameterFamily::NewL (*pnpBundle , EUPnPSubscribeRequestParamSet);

  1132 	TInt subscriptionDuration;

  1133     _LIT(KSubscriptionDuration, "subscriptionduration");

  1134 	GetIntFromConfig(GetCurrentSection(), KSubscriptionDuration, subscriptionDuration);

  1135 	TBool readIni = EFalse;