diff -r 000000000000 -r f5a58ecadc66 servicediscoveryandcontrol/pnp/test/upnp/IntegTest/testupnp/src/testupnpmanager.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/servicediscoveryandcontrol/pnp/test/upnp/IntegTest/testupnp/src/testupnpmanager.cpp Tue Feb 02 01:12:20 2010 +0200
@@ -0,0 +1,3558 @@
+// Copyright (c) 2008-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:
+// Contains implementation of CTestUPnPManager class
+// Contains implemenatation of CTestUPnPManager, CUPnPObserver, CUPnPTimer,
+// and CAction classes
+//
+//
+
+#include "testupnpmanager.h"
+
+
+/*
+ Constructor:
+ @internalTechnology
+ @test
+*/
+CTestUPnPManager::CTestUPnPManager()
+: CTestStep()
+ {
+ iCancelDiscovery = EFalse;
+ iExpectedData = EFalse;
+ iDiscoverySuccess = EFalse;
+ iNotifyCount = 0;
+ iPublishCount = 0;
+ iDescribeResponseCount = 0;
+ iRenewCount = 0;
+ iFailedNumUris = 0;
+ }
+
+/*
+ Initializes all member vaiables.
+ @param None.
+ @return None.
+*/
+void CTestUPnPManager::InitializeL()
+ {
+ iScheduler = new (ELeave) CActiveScheduler;
+ CActiveScheduler::Install(iScheduler);
+ }
+
+/*
+ Destructor
+ @internalTechnology
+ @test
+*/
+CTestUPnPManager::~CTestUPnPManager()
+ {
+ _LIT(KInfoDesctructorBegin, "Begin: In Destructor CTestUpnPanager....\n");
+ INFO_PRINTF1(KInfoDesctructorBegin);
+ if(iStringPoolMgr)
+ {
+ iStringPoolMgr->Release();
+ //this will tkae care of clean up of iStringPool
+ }
+ _LIT(KInfoDesctructorBegin2, "Releasing String Pool Manager....\n");
+ INFO_PRINTF1(KInfoDesctructorBegin2);
+
+ CleanUpObserverArray();
+ iDeviceLocationArray.Close();
+ CleanUpResultsArray();
+ DescriptionSuiteCleanUp();
+ ScpdUriArrayCleanUp();
+ ControlUriArrayCleanUp();
+ EventUriArrayCleanUp();
+ CloseDiscoverer();
+ //#ifdef _DEBUG
+ ClosePublisher();
+ CActiveScheduler::Install(NULL); //Testing for ONB hangs
+ _LIT(KInfoDesctructorBegin1, "Deleting the Active Schedulers....\n");
+ INFO_PRINTF1(KInfoDesctructorBegin1);
+ delete iScheduler;
+ iScheduler = NULL;
+ //#endif //_Debug
+
+ iPublisherObserverMap.Close();
+ _LIT(KInfoDesctructorEnd, "End: ....In Destructor CTestUpnPanager\n");
+ INFO_PRINTF1(KInfoDesctructorEnd);
+
+ //iConnection.Close ();
+ //iSocketServ.Close ();
+ }
+
+void CTestUPnPManager::ClosePublisher()
+ {
+ _LIT(KInfoLogFile, "ClosePublisher....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ CancelPublish();
+ }
+
+void CTestUPnPManager::CloseDiscoverer()
+ {
+ iControlPoint.Close();
+ }
+
+void CTestUPnPManager::CleanUpObserverArray()
+ {
+ _LIT(KInfoLogFile, "CleanUpObserverArray....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ if (iObserverArray.Count() > 0 )
+ {
+ iObserverArray.ResetAndDestroy();
+ }
+ else
+ {
+ iObserverArray.Close();
+ }
+ _LIT(KInfoLogFile1, "CleanUpObserverArray End....\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::CleanUpResultsArray()
+ {
+ _LIT(KInfoLogFile, "CleanUpResultsArray....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iResultsArray.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iResultsArray[index].Close();
+ }
+ iResultsArray.Close();
+ _LIT(KInfoLogFile1, "CleanUpResultsArray End....\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::DescriptionSuiteCleanUp()
+ {
+ _LIT(KInfoLogFile, "DescriptionSuiteCleanUp....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iDescriptionSuiteArray.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iDescriptionSuiteArray[index].iBaseUrl.Close();
+ iDescriptionSuiteArray[index].iDescription.Close();
+ DeleteSeriveUrlsList(index);
+ }
+ iDescriptionSuiteArray.Close();
+ _LIT(KInfoLogFile1, "DescriptionSuiteCleanUp End...\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ScpdUriArrayCleanUp()
+ {
+ _LIT(KInfoLogFile, "ScpdUriArrayCleanUp....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iScpdUriArray.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iScpdUriArray[index].Close();
+ }
+ iScpdUriArray.Close();
+
+ count = iIconUriArray.Count ();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iIconUriArray[index].Close();
+ }
+ iIconUriArray.Close();
+
+ _LIT(KInfoLogFile1, "ScpdUriArrayCleanUp End....\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::EventUriArrayCleanUp()
+ {
+ _LIT(KInfoLogFile, "EventUriArrayCleanUp....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iEventUriArray.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iEventUriArray[index].Close();
+ }
+ iEventUriArray.Close();
+ _LIT(KInfoLogFile1, "EventUriArrayCleanUp End....\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ControlUriArrayCleanUp()
+ {
+ _LIT(KInfoLogFile, "ControlUriArrayCleanUp....\n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iControlUriArray.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ iControlUriArray[index].Close();
+ }
+ iControlUriArray.Close();
+ _LIT(KInfoLogFile1, "ControlUriArrayCleanUp End....\n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Implementation of CTestStep base class virtual and this is used for doing all
+ initialisation common
+ to derived classes here.
+ @param None
+ @return TVerdict
+ */
+TVerdict CTestUPnPManager::doTestStepPreambleL()
+ {
+ InitializeL();
+ SavePreviousLogFileL();
+ return CTestStep::doTestStepPreambleL();
+ }
+
+/*
+ Save the previous log file...if any
+*/
+void CTestUPnPManager::SavePreviousLogFileL()
+ {
+ _LIT(KInfoLogFile, "Saving Previous logs If any.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ RFs fileserv;
+ TInt error = fileserv.Connect();
+ if(!error)
+ {
+ _LIT(KlogFile, "C:\\logs\\log.txt");
+ _LIT(KPrefixLog, "C:\\upnplogs\\");
+ _LIT(KSuffix, "_UDEB");
+ _LIT(KExtn, ".txt");
+
+ CFileMan* fMan = NULL;
+ TRAP_IGNORE(fMan = CFileMan::NewL(fileserv));
+ if(fMan != NULL)
+ {
+ CleanupStack::PushL(fMan);
+ RBuf newFileName, traceFileName ;
+ const TInt KTwentyFour = 24;
+ newFileName.Create(ConfigSection().Length() + KTwentyFour );
+ newFileName.Copy(KPrefixLog);
+ //Script file name
+ iScriptName.Copy(ConfigSection());
+ newFileName.Append(iScriptName);
+ newFileName.Append(KSuffix);
+ newFileName.Append(KExtn);
+ TInt error = fMan->Rename(KlogFile, newFileName);
+
+ if (error != KErrNone)
+ {
+ _LIT(KErrInfo, "Unable to Save Previous logs...May be NO Previous logs exist \n");
+ ERR_PRINTF1(KErrInfo);
+ }
+ else
+ {
+ _LIT(KSavingInfo, "Saved Previous logs with File Name: %S \n");
+ INFO_PRINTF2(KSavingInfo, &newFileName);
+
+ //btracelog
+ _LIT(KBtracelogFile, "C:\\logs\\btrace.log");
+ _LIT(KBTrace, "btrace.log");
+ traceFileName.Create(KPrefixLog().Length() + iScriptName.Length() + KBTrace().Length() );
+ traceFileName.Copy(KPrefixLog);
+ traceFileName.Append(iScriptName);
+ traceFileName.Append(KBTrace);
+ error = fMan->Rename(KBtracelogFile, traceFileName);
+ if ( error == KErrNone )
+ {
+ _LIT(KBtraceInfo, "Saved Previous btrace logs with File Name: %S \n");
+ INFO_PRINTF2(KBtraceInfo, &traceFileName);
+ }
+ }
+ CleanupStack::PopAndDestroy(fMan);
+ newFileName.Close();
+ traceFileName.Close ();
+ }
+ }
+ fileserv.Close();
+ _LIT(KInfoLogFile1, "Saving Previous logs End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ return Script File name..if any
+*/
+const TDesC& CTestUPnPManager::ScriptFileName()
+ {
+ return iScriptName;
+ }
+
+/*
+ Implementation of CTestStep base class virtual and it is used for doing all
+ after test treatment common to derived classes in here.
+ @return TVerdict
+ */
+TVerdict CTestUPnPManager::doTestStepPostambleL()
+ {
+ return CTestStep::doTestStepPostambleL();
+ }
+
+
+TVerdict CTestUPnPManager::doTestStepL()
+ {
+ SequenceOperationsL();
+ return TestStepResult();
+ }
+
+/*
+ This function performs operations based on sequence specified in the ini file
+ @param None
+ @return None
+*/
+void CTestUPnPManager::SequenceOperationsL()
+ {
+ _LIT(KInfoLogFile, "SequenceOperationsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ RArray sequenceList;
+ CleanupClosePushL(sequenceList);
+ TPtrC listOfSequences;
+ _LIT(KListOfSequences, "listofsequences");
+ GetStringFromConfig(ConfigSection(), KListOfSequences, listOfSequences);
+
+ TokenizeStringL(listOfSequences, sequenceList);
+ TInt numOperations = sequenceList.Count();
+
+ for(TInt i(0); i < numOperations; i++)
+ {
+ SetCurrentSection(sequenceList[i]);
+ PerformDesiredOperationsL(sequenceList[i]);
+ }
+ CleanupStack::PopAndDestroy();
+ _LIT(KInfoLogFile1, "SequenceOperationsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void TestUtils::LoadESockL ( RSocketServ& aSocketServ, RConnection& aConnection )
+ {
+ User::LeaveIfError ( aSocketServ.Connect () );
+ User::LeaveIfError ( aConnection.Open ( aSocketServ ) );
+ TRequestStatus status;
+ aConnection.Start ( status );
+ User::WaitForRequest ( status );
+ User::LeaveIfError ( status.Int () );
+ aConnection.CancelAllInterfaceNotification ();
+ aConnection.CancelProgressNotification ();
+ aConnection.CancelServiceChangeNotification ();
+ aConnection.CancelAllSubConnectionNotification ();
+ }
+
+/*
+ This function performs desired operations specified as a parameter
+ @param aOperation string representing operation to be performed
+ @return None
+*/
+void CTestUPnPManager::PerformDesiredOperationsL(const TDesC& aOperation)
+ {
+ const TInt KMatch = 0;
+ TPtrC operationType;
+ _LIT(KOperationType, "operationtype");
+ GetStringFromConfig(aOperation, KOperationType, operationType);
+
+ /*if ( iConnection.SubSessionHandle () == 0 )
+ {
+ TestUtils::LoadESockL ( iSocketServ, iConnection );
+ }*/
+
+ if(operationType.Compare(KOpenDiscoverer) == KMatch)
+ {
+ OpenDiscovererL();
+ }
+ else if(operationType.Compare(KOpenPublisher) == KMatch)
+ {
+ OpenMultiplePublisherL();
+ }
+ else if(operationType.Compare(KDiscovery) == KMatch)
+ {
+ DiscoverL(aOperation);
+ }
+ else if(operationType.Compare(KCancelDiscover) == KMatch)
+ {
+ CancelDiscoverL(aOperation);
+ }
+ else if(operationType.Compare(KCancelDescribe) == KMatch)
+ {
+ CancelDescribeL(aOperation);
+ }
+ else if(operationType.Compare(KPublishService) == KMatch)
+ {
+ PublishServiceL(aOperation);
+ }
+ else if(operationType.Compare(KPublishDevice) == KMatch)
+ {
+ PublishDeviceL(aOperation);
+ }
+ else if(operationType.Compare(KDescribe) == 0)
+ {
+ DescribeL();
+ }
+ else if(operationType.Compare(KDescribeService) == 0)
+ {
+ DescribeServiceL();
+ }
+ else if(operationType.Compare(KSubscribe) == 0)
+ {
+ SubscribeForStateChangeNotificationsL();
+ }
+ else if(operationType.Compare(KUnsubscribe) == 0)
+ {
+ UnsubscribeForStateChangeNotificationsL(aOperation);
+ }
+ else if(operationType.Compare(KRegisterAnnouncement) == KMatch)
+ {
+ RegisterForAnnouncementsL(aOperation);
+ }
+ else if(operationType.Compare(KCancelNotify) == KMatch)
+ {
+ CancelNotifyAnnouncementL(aOperation);
+ }
+ else if(operationType.Compare(KInitiateControl) == KMatch)
+ {
+ InitiateActionL(aOperation);
+ }
+ else if ( operationType.Compare(KDescribeIcon) == KMatch)
+ {
+ DescribeIconL();
+ }
+ else if(operationType.Compare(KStartScheduler) == KMatch)
+ {
+ CActiveScheduler::Start();
+ }
+ else if(operationType.Compare(KStopScheduler) == KMatch)
+ {
+ CActiveScheduler::Stop();
+ }
+ else if(operationType.Compare(KStartTimer) == KMatch)
+ {
+ StartTimerL(aOperation);
+ }
+ else if(operationType.Compare(KPrintResults) == 0)
+ {
+ PrintAndValidateResultsL(aOperation);
+ }
+ }
+
+/*
+ Parses a comma separated string and constructs a list out of the values
+ @param aString a reference to a string to be tokenized
+ @param aList is an out parameter to store a list of tokens in an arry
+ @param aSeparator is a character used to delimit the tokens
+ */
+void CTestUPnPManager::TokenizeStringL(const TDesC& aString, RArray& aList, TChar aSeparator)
+ {
+ TLex lexer(aString);
+
+ while(!lexer.Eos())
+ {
+ lexer.SkipSpaceAndMark();
+
+ while(!lexer.Eos() && lexer.Get() != aSeparator)
+ {
+ }
+
+ if(!lexer.Eos())
+ {
+ lexer.UnGet();
+ }
+ aList.AppendL(lexer.MarkedToken());
+ lexer.Inc();
+ }
+ }
+
+/*
+ Starts a timer for a wait time and triggers CallBack function as timer expires.
+ @param None
+ @return None
+ */
+void CTestUPnPManager::StartTimerL(const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "StartTimerL.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ _LIT(KWaitTime,"waittime");
+ TInt waitTime = 0;
+ GetIntFromConfig(aOperationType, KWaitTime, waitTime);
+// TTimeIntervalMicroSeconds32 interval(waitTime);
+ CUPnPTimer* timer = CUPnPTimer::NewL(this);
+ CleanupStack::PushL(timer);
+ timer->IssueRequestL(waitTime);
+ CActiveScheduler::Start();
+ CleanupStack::PopAndDestroy(timer);
+ _LIT(KInfoLogFile1, "StartTimerL End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Sets the current config section.
+ @param aCurrentSection - a reference string that represent current config section
+ @return None
+ */
+void CTestUPnPManager::SetCurrentSection(const TDesC& aCurrentSection)
+ {
+ iCurrentSection = aCurrentSection;
+ }
+
+/*
+ Retrieve the current config section.
+ @param
+ @return Reference to current config section
+ */
+TDesC& CTestUPnPManager::GetCurrentSection()
+ {
+ return iCurrentSection;
+ }
+
+/*
+ Tests whether discovering services/devices is performing as specified in UPnP specifications.
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+void CTestUPnPManager::DiscoverL(const TDesC& aOperationType)
+ {
+ RArray serviceTypeList;
+ RArray mxTimeList;
+ TPtrC listOfServiceTypes;
+ TPtrC listOfMxTimes;
+ _LIT(KListOfServiceTypes, "listofservicetypes");
+ _LIT(KListOfMxTimes, "listofmxtimes");
+ _LIT(KInfoLogFile, "DiscoverL.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.Open ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPDiscoverRequestParamSet);
+ if(!GetStringFromConfig(GetCurrentSection(), KListOfServiceTypes, listOfServiceTypes)
+ || !GetStringFromConfig(GetCurrentSection(), KListOfMxTimes, listOfMxTimes))
+ {
+ _LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: \n%S, \n%S \n");
+ ERR_PRINTF3( KErrInfo, &KListOfServiceTypes, &KListOfMxTimes );
+ //SetTestStepResult(EFail);
+ return;
+ }
+
+ TokenizeStringL(listOfServiceTypes, serviceTypeList);
+ TokenizeStringL(listOfMxTimes, mxTimeList);
+ TInt numUris = serviceTypeList.Count();
+ iFailedNumUris = serviceTypeList.Count(); //This should be of Unique Uri's count
+ TInt numMxs = mxTimeList.Count();
+ TLex responseTimeObj;
+ //__ASSERT_DEBUG ( numUris == numMxs, User::Panic (KDescoveryTestPanicCategory, KErrMissingURiOrResponceTime ) );
+ RBuf8 buf;
+ buf.Create(KMaxUriSize);
+ for(TInt i(0); i < numUris; i++)
+ {
+ CUPnPDiscoverRequestParamSet* discoverParamSet = CUPnPDiscoverRequestParamSet::NewL(pnpFamily );
+ buf.Copy(serviceTypeList[i]);
+ discoverParamSet->SetUriL( buf );
+ //response time
+ responseTimeObj.Assign(mxTimeList[i]);
+ TInt responseTime(0);
+ responseTimeObj.Val(responseTime);
+ discoverParamSet->SetResponseTime(responseTime);
+ }
+ buf.Close();
+ mxTimeList.Close();
+ serviceTypeList.Close();
+ iControlPoint.Discover(pnpBundle);
+
+ TBool delayEnabled = EFalse;
+ _LIT(KDelayEnabled, "delayenabled");
+ GetBoolFromConfig(GetCurrentSection(), KDelayEnabled, delayEnabled);
+
+ TBool SchedulerStatus = ETrue;
+ _LIT(KSchedulerStatus, "schedulerstart");
+ GetBoolFromConfig(GetCurrentSection(), KSchedulerStatus, SchedulerStatus);
+
+ if(SchedulerStatus)
+ {
+ CActiveScheduler::Start();
+ }
+
+ if(!IsDiscoverySuccess() && iFailedNumUris <= 0 )
+ {
+ //In Case of failure of Discovery....Trying once more to Discover.
+ //Retrty Discovery only if and only if All Uri's Timedout
+ _LIT(KInfoDiscoverRetry, "Retrying Discovery.... \n");
+ INFO_PRINTF1(KInfoDiscoverRetry );
+ SetDiscoveryStatus(ETrue);
+ iControlPoint.Discover(pnpBundle);
+ if(SchedulerStatus)
+ {
+ CActiveScheduler::Start();
+ }
+ }
+ if(delayEnabled)
+ {
+ StartTimerL(aOperationType);
+ }
+ _LIT(KInfoLogFile1, "DiscoverL End... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ }
+
+TBool CTestUPnPManager::IsDiscoverySuccess()
+ {
+ return iDiscoverySuccess;
+ }
+
+void CTestUPnPManager::SetDiscoveryStatus(TBool aSuccess)
+ {
+ _LIT(KInfoDiscoverSetStatus, "Setting iDiscoverySuccesss Flag to %d \n");
+ INFO_PRINTF2(KInfoDiscoverSetStatus, aSuccess );
+ iDiscoverySuccess = aSuccess;
+ }
+
+/*
+ Tests whether Publishing a Service/Device is performing as specified in UPnP specifications.
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+void CTestUPnPManager::PublishServiceL (const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "PublishServiceL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+ //To keep track of mapping between Observer and Publisher
+ TInt observerIndex = iObserverArray.Count() - 1;
+ RPnPParameterBundle pnpBundle ;
+ pnpBundle.Open();
+
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily family = pnpBundle.CreateFamilyL(EUPnPServiceRegisterParamSet);
+
+
+ CUPnPServiceRegisterParamSet* registerServiceParamSet = CUPnPServiceRegisterParamSet::NewL(family );
+ TPtrC serviceType;
+ GetStringFromConfig(aOperationType, KServiceType, serviceType);
+ RBuf8 serviceTypeBuf;
+ serviceTypeBuf.Create(serviceType.Length());
+ serviceTypeBuf.Copy(serviceType);
+
+ TPtrC usn;
+ GetStringFromConfig(aOperationType, KUSN, usn);
+ RBuf8 usnBuf;
+ usnBuf.Create(usn.Length());
+ usnBuf.Copy(usn);
+
+ TInt duration;
+ GetIntFromConfig(aOperationType, KCacheControl, duration);
+
+ TPtrC description;
+ GetStringFromConfig(aOperationType, KDescription, description);
+ RBuf8 descriptionBuf;
+ descriptionBuf.Create(description.Length());
+ descriptionBuf.Copy(description);
+
+ TInt serviceduration = 300;
+ GetIntFromConfig(aOperationType, KServiceMaxDuration, serviceduration);
+
+ registerServiceParamSet->SetUriL ( serviceTypeBuf );
+ registerServiceParamSet->SetDeviceUidL ( usnBuf );
+ registerServiceParamSet->SetCacheControlData ( duration );
+ registerServiceParamSet->SetSubscriptionDuration(serviceduration);
+
+ ExtractServiceDescriptionL (aOperationType, *registerServiceParamSet);
+
+ _LIT8(KInitialMessage, "Initial Service Message");
+ registerServiceParamSet->SetInitialMessageL(KInitialMessage);
+
+ //To keep track of mapping between Observer and Publisher
+ TInt publisherIndex = OpenPublisherL();
+ //Create mapping of Publsiher and observer
+ TPublisherObserverMap publisherObserverMapElement;
+ publisherObserverMapElement.iPublisherIndex = publisherIndex;
+ publisherObserverMapElement.iObserverIndex = observerIndex;
+ publisherObserverMapElement.iPublisherControl = KService;
+ iPublisherObserverMap.Append(publisherObserverMapElement);
+
+ //Publish service nad update publish count
+ iPublishCount++;
+ iPublisherArray[publisherIndex].Publish( pnpBundle );
+
+ TBool SchedulerStart = EFalse;
+ _LIT(KSchedulerStart, "schedulerstart");
+ GetBoolFromConfig(aOperationType, KSchedulerStart, SchedulerStart);
+ if(SchedulerStart)
+ {
+ CActiveScheduler::Start();
+ }
+ _LIT(KInfoLogFile1, "PublishServiceL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ descriptionBuf.Close();
+ usnBuf.Close();
+ serviceTypeBuf.Close();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ }
+
+/*
+ * Get publisher mapping index for the given observer index
+ */
+TInt CTestUPnPManager::GetPublisherIndex (TInt aObserverIndex)
+ {
+ _LIT(KInfoLogFile, "GetPublisherIndex.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TInt count = iPublisherObserverMap.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)
+ {
+ return iPublisherObserverMap[index].iPublisherIndex;
+ }
+ }
+ return KErrNotFound;
+ }
+
+/*
+ * Gets publisher control i.e, Device/Service for the given observer index
+ */
+TPublisherControl CTestUPnPManager::GetPublisherControl (TInt aObserverIndex)
+ {
+ _LIT(KInfoLogFile, "GetPublisherControl.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TInt count = iPublisherObserverMap.Count();
+ for (TInt index(0); index < count ; index++ )
+ {
+ if (iPublisherObserverMap[index].iObserverIndex == aObserverIndex)
+ {
+ return iPublisherObserverMap[index].iPublisherControl;
+ }
+ }
+ return KErrNoControl;
+ }
+
+/*
+ * Gets publisher control i.e, Device/Service for the given observer index
+ */
+TPublisherControl CTestUPnPManager::PublisherType (TInt aPublisherIndex)
+ {
+ _LIT(KInfoLogFile, "PublisherType.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iPublisherObserverMap.Count();
+ TPublisherControl publisherControl = KErrNoControl;
+ for (TInt index(0); index < count ; index++ )
+ {
+ if (iPublisherObserverMap[index].iPublisherIndex == aPublisherIndex)
+ {
+ switch (iPublisherObserverMap[index].iPublisherControl)
+ {
+ case KService:
+ {
+ publisherControl = KService;
+ break;
+ }
+ case KDevice:
+ {
+ publisherControl = KDevice;
+ break;
+ }
+ default :
+ {
+ publisherControl = KErrNoControl;
+ break;
+ }
+ }
+ }
+ }
+ _LIT(KInfoLogFile2, "PublisherType....End \n");
+ INFO_PRINTF1(KInfoLogFile2);
+ return publisherControl;
+ }
+
+TInt CTestUPnPManager::NotifyCount()
+ {
+ return iNotifyCount;
+ }
+
+TBool CTestUPnPManager::SendNotificationsL (CUPnPObserver* aObserver)
+ {
+ _LIT(KInfoLogFile, "SendNotificationsL.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TInt observerIndex = iObserverArray.Find(aObserver);
+ TInt publisherIndex = GetPublisherIndex(observerIndex);
+ TPublisherControl publisherControl = GetPublisherControl(observerIndex);
+
+ if(publisherControl != KService)
+ {
+ _LIT(KSendNotifyErr,"SEND NOTIFY NOT EXECUTED -- Can be Executed only ON Services...\n");
+ ERR_PRINTF1(KSendNotifyErr);
+ return EFalse;
+ }
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.Open();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)this);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL(EUPnPServiceNotificationParamSet);
+ CUPnPServiceNotificationParamSet* ServiceNotifyParamSet = CUPnPServiceNotificationParamSet::NewL (pnpFamily );
+
+ RBuf8 notificationDataBuf;
+ notificationDataBuf.CreateL(_L8("notification"));
+
+ ServiceNotifyParamSet->SetNotificationL (notificationDataBuf );
+ iNotifyCount++;
+ if(publisherIndex >= 0)
+ {
+ iPublisherArray[publisherIndex].SendNotify( pnpBundle );
+ _LIT(KSendNotify,"Info: SEND NOTIFY SUCCESSFUL...\n");
+ INFO_PRINTF1(KSendNotify);
+ }
+ else
+ {
+ _LIT(KSendNotifyFailed,"Err: SEND NOTIFY UNSUCCESSFUL...\n");
+ ERR_PRINTF1(KSendNotifyFailed);
+ }
+
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ notificationDataBuf.Close();
+ _LIT(KInfoLogFile1, "SendNotificationsL End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ return ETrue;
+ }
+
+/*
+ Extract service description available in a file, copy it to the buffer and append the same to service register paramset.
+ @param aConfigSection - reference to a section name in ini file where required parameters that needs to be referred for this operation.
+ aServiceRegisterParamSet - Storage for the description buffer
+ @return None.
+ */
+
+void CTestUPnPManager::ExtractServiceDescriptionL (const TDesC& aConfigSection, CUPnPServiceRegisterParamSet& aServiceRegisterParamSet)
+ {
+ _LIT(KInfoLogFile, "ExtractServiceDescriptionL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TPtrC descriptionPath;
+ _LIT(KDescriptionPath, "Description_Path");
+ GetStringFromConfig(aConfigSection, KDescriptionPath, descriptionPath);
+
+ TPtrC description;
+ _LIT(KDescription, "description");
+ GetStringFromConfig(aConfigSection, KDescription, description);
+
+ if((descriptionPath == KNullDesC) && (description == KNullDesC))
+ {
+ _LIT8(KDefaultServiceDescription, "defaultservicedescription");
+ TBuf8 descBuf;
+ descBuf.Copy(KDefaultServiceDescription);
+ aServiceRegisterParamSet.SetServiceDescriptionL (descBuf);
+ return;
+ }
+ else
+ {
+ RFs fs;
+ RFile file;
+ TInt err;
+ RBuf8 buf;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ if(descriptionPath != KNullDesC)
+ {
+ err = file.Open(fs, descriptionPath, EFileShareReadersOnly);
+
+ // For Hardware system path is c:, so descriptionPath value present in '.ini' is referring 'c:'
+ if ( err == KErrPathNotFound )
+ {
+ RBuf fileName;
+ TDriveName aSystemDrive;
+ TDriveUnit driveunit(RFs::GetSystemDrive());
+ aSystemDrive.Zero();
+ aSystemDrive=driveunit.Name();
+ fileName.CreateL ( descriptionPath.Length () );
+ fileName.Zero();
+ fileName.Append(aSystemDrive);
+ fileName.Append ( descriptionPath.Mid ( aSystemDrive.Length () ) );
+
+ err = file.Open(fs, fileName, EFileShareReadersOnly);
+ }
+ }
+ else
+ {
+ err = file.Open(fs, description, EFileShareReadersOnly);
+
+ // For Hardware system path is c:, so description value present in '.ini' is referring 'c:'
+ if ( err == KErrPathNotFound )
+ {
+ RBuf fileName;
+ TDriveName aSystemDrive;
+ TDriveUnit driveunit(RFs::GetSystemDrive());
+ aSystemDrive.Zero();
+ aSystemDrive=driveunit.Name();
+ fileName.CreateL ( description.Length () );
+ fileName.Zero();
+ fileName.Append(aSystemDrive);
+ fileName.Append ( description.Mid ( aSystemDrive.Length () ) );
+
+ err = file.Open(fs, fileName, EFileShareReadersOnly);
+ }
+ }
+
+ if (err != KErrNone)
+ {
+ User::LeaveIfError(err);
+ }
+ CleanupClosePushL(file);
+ TInt fileSize = 0;
+ file.Size(fileSize);
+ buf.Create(fileSize);
+ err = file.Read(buf, fileSize);
+ aServiceRegisterParamSet.SetServiceDescriptionL ( buf );
+ _LIT(KServiceDescription, "ServiceDescription is.... %S \n");
+ INFO_PRINTF2(KServiceDescription, &buf);
+ CleanupStack::PopAndDestroy(2);
+ buf.Close();
+ }
+ _LIT(KInfoLogFile1, "ExtractServiceDescriptionL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ResolveScpdUrisL(TInt aIndex)
+ {
+ _LIT(KInfoLogFile, "ResolveScpdUrisL .... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ if ( aIndex < 0 )
+ {
+ _LIT(KBadIndex, "BadIndex...ResolveScpdUrisL Cannot be executed \n");
+ ERR_PRINTF1(KBadIndex);
+ return;
+ }
+ const TInt KSlashLenghth = 1;
+ TUriParser8 uri;
+ uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);
+ TBuf8 buf;
+ buf.Copy(uri.Extract(EUriScheme));
+
+ buf.Append(KColonSlashSlash);
+ buf.Append(uri.Extract(EUriHost));
+
+ buf.Append(KColon);
+ buf.Append(uri.Extract(EUriPort));
+
+ TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();
+ for (TInt scpdIndex(0); scpdIndex < count; scpdIndex++ )
+ {
+ RBuf8 scpdUri;
+ scpdUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Length());
+ scpdUri.Copy(buf);
+ if (iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl.Find(KSlash)!=0)
+ {
+ scpdUri.Append(KSlash);
+ }
+ scpdUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[scpdIndex].scpdUrl);
+ AppendScpdUriL(scpdUri);
+ }
+ _LIT(KInfoLogFile1, "ResolveScpdUrisL End .... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ResolveEventUrisL(TInt aIndex)
+ {
+ _LIT(KInfoLogFile, "ResolveEventUrisL.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ if ( aIndex < 0 )
+ {
+ _LIT(KBadIndex, "BadIndex...ResolveEventUrisL Cannot be executed \n");
+ ERR_PRINTF1(KBadIndex);
+ return;
+ }
+ const TInt KSlashLenghth = 1;
+ TUriParser8 uri;
+ uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);
+ TBuf8 buf;
+ buf.Copy(uri.Extract(EUriScheme));
+
+ buf.Append(KColonSlashSlash);
+ buf.Append(uri.Extract(EUriHost));
+
+ buf.Append(KColon);
+ buf.Append(uri.Extract(EUriPort));
+
+ TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();
+ for (TInt eventIndex(0); eventIndex < count; eventIndex++ )
+ {
+ RBuf8 eventUri;
+ eventUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Length());
+ eventUri.Copy(buf);
+ if (iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl.Find(KSlash)!=0)
+ {
+ eventUri.Append(KSlash);
+ }
+ eventUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[eventIndex].eventSubUrl);
+ AppendEventUriL(eventUri);
+ }
+ _LIT(KInfoLogFile1, "ResolveEventUrisL End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ }
+
+void CTestUPnPManager::ResolveControlUrisL(TInt aIndex)
+ {
+ _LIT(KInfoLogFile, "ResolveControlUrisL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ if ( aIndex < 0 )
+ {
+ _LIT(KBadIndex, "BadIndex...ResolveControlUrisL Cannot be executed \n");
+ ERR_PRINTF1(KBadIndex);
+ return;
+ }
+ const TInt KSlashLenghth = 1;
+ TUriParser8 uri;
+ uri.Parse(iDescriptionSuiteArray[aIndex].iBaseUrl);
+ TBuf8 buf;
+ buf.Copy(uri.Extract(EUriScheme));
+
+ buf.Append(KColonSlashSlash);
+ buf.Append(uri.Extract(EUriHost));
+
+ buf.Append(KColon);
+ buf.Append(uri.Extract(EUriPort));
+
+ TInt count = iDescriptionSuiteArray[aIndex].iServiceUrls.Count();
+ for (TInt ControlIndex(0); ControlIndex < count; ControlIndex++ )
+ {
+ RBuf8 controlUri;
+ controlUri.Create(buf.Length() + KSlashLenghth + iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Length());
+ controlUri.Copy(buf);
+ if (iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl.Find(KSlash)!=0)
+ {
+ controlUri.Append(KSlash);
+ }
+ controlUri.Append(iDescriptionSuiteArray[aIndex].iServiceUrls[ControlIndex].controlUrl);
+ AppendControlUriL(controlUri);
+ }
+ _LIT(KInfoLogFile1, "ResolveControlUrisL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ResolveIconUrlL ( TInt aBaseDescIdx, const TDesC8& aUrl )
+ {
+ _LIT(KInfoLogFile, "ResolveIconUrlL.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ const TInt KSlashLength = 1;
+ TUriParser8 uri;
+ uri.Parse(iDescriptionSuiteArray[aBaseDescIdx].iBaseUrl);
+ TBuf8 buf;
+ buf.Copy(uri.Extract(EUriScheme));
+
+ buf.Append(KColonSlashSlash);
+ buf.Append(uri.Extract(EUriHost));
+
+ buf.Append(KColon);
+ buf.Append(uri.Extract(EUriPort));
+
+ RBuf8 iconUri;
+ if ( aUrl[0] == TChar('/') )
+ {
+ iconUri.Create(buf.Length() + aUrl.Length());
+ iconUri.Copy(buf);
+ iconUri.Append (aUrl);
+ }
+ else
+ {
+ iconUri.Create(buf.Length() + KSlashLength + aUrl.Length());
+ iconUri.Copy(buf);
+ iconUri.Append(KSlash);
+ iconUri.Append (aUrl);
+ }
+
+ iIconUriArray.Append (iconUri);
+
+ _LIT(KInfoLogFile1, "ResolveIconUrlL End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Opens a handle to a RPnPServiceDiscovery object
+ @param None.
+ @return None.
+ */
+void CTestUPnPManager::OpenDiscovererL()
+ {
+ _LIT(KInfoLogFile, "OpenDiscovererL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TBool cpStatus = EFalse;
+ TInt openStatus = 0;
+ _LIT(KCpStatus, "cpstatus");
+ GetBoolFromConfig(GetCurrentSection(), KCpStatus, cpStatus);
+ if(!cpStatus)
+ {
+ _LIT(KInfoDiscoverer, "Control Point should not be Created \n");
+ INFO_PRINTF1(KInfoDiscoverer);
+ return;
+ }
+ for(TInt i=0;i<3;i++)
+ {
+ openStatus = iControlPoint.Open(KTierId);
+ if(openStatus == KErrNone)
+ {
+ break;
+ }
+ }
+ if(openStatus != KErrNone)
+ {
+ _LIT(KOpenDiscovererFailed, "Control Point discovery open failed with error %d ");
+ ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+ SetTestStepError(openStatus);
+ //SetTestStepResult(EFail);
+ }
+ else
+ {
+ _LIT(KOpenDiscovererSuccess, "Control Point Discovery was successfully started with return value %d :");
+ INFO_PRINTF2(KOpenDiscovererSuccess, openStatus);
+ }
+ }
+
+/*
+ Opens a handle to a RPnPServicePublisher object and append the same to Publisher array
+ @param None.
+ @return TBool representing success or failure of the operation.
+ */
+TInt CTestUPnPManager::OpenPublisherL()
+ {
+ _LIT(KInfoLogFile, "OpenPublisherL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ RPnPServicePublisher publisher;
+ TInt openStatus = 0;
+ for(TInt i=0;i<3;i++)
+ {
+ openStatus = publisher.Open(KTierId);
+ if(openStatus == KErrNone)
+ {
+ break;
+ }
+ }
+ if( openStatus != KErrNone )
+ {
+ _LIT(KOpenDiscovererFailed, "Publisher open failed with error %d ");
+ ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+ //SetTestStepResult(EFail);
+ }
+ else
+ {
+ _LIT(KOpenPublisherSuccess, "Service publisher was successfully started with return value %d :");
+ INFO_PRINTF2(KOpenPublisherSuccess, openStatus);
+ }
+ iPublisherArray.Append(publisher);
+ TInt index = iPublisherArray.Count() - 1;
+ return index;
+ }
+
+/*
+ Opens a handle to a RPnPServicePublisher object and append the same to Publisher array
+ @param None.
+ @return TBool representing success or failure of the operation.
+ */
+void CTestUPnPManager::OpenMultiplePublisherL()
+ {
+ _LIT(KInfoLogFile, "MultipleOpenPublisherL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ static RPnPServicePublisher publisher;
+ TInt openStatus = 0;
+ for(TInt i=0;i<3;i++)
+ {
+ openStatus = publisher.Open(KTierId);
+ if(openStatus == KErrNone)
+ {
+ break;
+ }
+ }
+ if( openStatus != KErrNone )
+ {
+ _LIT(KOpenDiscovererFailed, "Publisher open failed with error %d ");
+ ERR_PRINTF2(KOpenDiscovererFailed, openStatus);
+ SetTestStepError(openStatus);
+ //SetTestStepResult(EFail);
+ }
+ else
+ {
+ _LIT(KOpenPublisherSuccess, "Service publisher was successfully started with return value %d :");
+ INFO_PRINTF2(KOpenPublisherSuccess, openStatus);
+ }
+ }
+
+
+
+/*
+ Publishing of device as per UPnP specifications.
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+
+void CTestUPnPManager::PublishDeviceL (const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "PublishDeviceL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ //To keep track of mapping between Observer and Publisher
+ TInt observerIndex = iObserverArray.Count() - 1;
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.Open();
+
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL(EUPnPDeviceRegisterParamSet);
+ CUPnPDeviceRegisterParamSet* registerDeviceParamSet = CUPnPDeviceRegisterParamSet::NewL(pnpFamily );
+ TPtrC parentdeviceuid;
+ GetStringFromConfig(aOperationType, KParentDeviceUid, parentdeviceuid);
+ RBuf8 parentdeviceuidBuf;
+ parentdeviceuidBuf.Create(parentdeviceuid.Length());
+ parentdeviceuidBuf.Copy(parentdeviceuid);
+
+ TPtrC devicetype;
+ GetStringFromConfig(aOperationType, KDeviceType, devicetype);
+ RBuf8 devicetypeBuf;
+ devicetypeBuf.Create(devicetype.Length());
+ devicetypeBuf.Copy(devicetype);
+
+ TPtrC friendlyname;
+ GetStringFromConfig(aOperationType, KFriendlyName, friendlyname);
+ RBuf8 friendlynameBuf;
+ friendlynameBuf.Create(friendlyname.Length());
+ friendlynameBuf.Copy(friendlyname);
+
+ TPtrC manufacturer;
+ GetStringFromConfig(aOperationType, KManufacturer, manufacturer);
+ RBuf8 manufacturerBuf;
+ manufacturerBuf.Create(manufacturer.Length());
+ manufacturerBuf.Copy(manufacturer);
+
+ TPtrC manufacturerurl;
+ GetStringFromConfig(aOperationType, KManufacturerURL, manufacturerurl);
+ RBuf8 manufacturerurlBuf;
+ manufacturerurlBuf.Create(manufacturerurl.Length());
+ manufacturerurlBuf.Copy(manufacturerurl);
+
+ TPtrC modeldescription;
+ GetStringFromConfig(aOperationType, KModelDescription, modeldescription);
+ RBuf8 modeldescriptionBuf;
+ modeldescriptionBuf.Create(modeldescription.Length());
+ modeldescriptionBuf.Copy(modeldescription);
+
+ TPtrC modelname;
+ GetStringFromConfig(aOperationType, KModelName, modelname);
+ RBuf8 modelnameBuf;
+ modelnameBuf.Create(modelname.Length());
+ modelnameBuf.Copy(modelname);
+
+ TPtrC modelnumber;
+ GetStringFromConfig(aOperationType, KModelNumber, modelnumber);
+ RBuf8 modelnumberBuf;
+ modelnumberBuf.Create(modelnumber.Length());
+ modelnumberBuf.Copy(modelnumber);
+
+
+ TPtrC modelurl;
+ GetStringFromConfig(aOperationType, KModelURL, modelurl);
+ RBuf8 modelurlBuf;
+ modelurlBuf.Create(modelurl.Length());
+ modelurlBuf.Copy(modelurl);
+
+ TPtrC presentationurl;
+ GetStringFromConfig(aOperationType, KPresentationURL, presentationurl);
+ RBuf8 presentationurlBuf;
+ presentationurlBuf.Create(presentationurl.Length());
+ presentationurlBuf.Copy(presentationurl);
+
+ TPtrC serialnumber;
+ GetStringFromConfig(aOperationType, KSerialNumber, serialnumber);
+ RBuf8 serialnumberBuf;
+ serialnumberBuf.Create(serialnumber.Length());
+ serialnumberBuf.Copy(serialnumber);
+
+ TPtrC udn;
+ GetStringFromConfig(aOperationType, KUDN, udn);
+ RBuf8 udnBuf;
+ udnBuf.Create(udn.Length());
+ udnBuf.Copy(udn);
+
+ TPtrC upc;
+ GetStringFromConfig(aOperationType, KUPC, upc);
+ RBuf8 upcBuf;
+ upcBuf.Create(upc.Length());
+ upcBuf.Copy(upc);
+
+ TInt duration;
+ GetIntFromConfig(aOperationType, KCacheControl, duration);
+
+ TPtrC iconRefer;
+ if ( GetStringFromConfig(aOperationType, KIconRefer, iconRefer) )
+ {
+
+ //iconRead:
+ do
+ {
+ TPtrC mimeType;
+ GetStringFromConfig(iconRefer, KMimeType, mimeType);
+ RBuf8 typeBuf;
+ typeBuf.Create(mimeType.Length());
+ typeBuf.Copy(mimeType);
+
+ TPtrC url;
+ GetStringFromConfig(iconRefer, KUrl, url);
+ RBuf8 urlBuf;
+ urlBuf.Create(url.Length());
+ urlBuf.Copy(url);
+
+ TInt width;
+ GetIntFromConfig(iconRefer, KWidth, width);
+
+ TInt height;
+ GetIntFromConfig(iconRefer, KHeight, height);
+
+ TInt depth;
+ GetIntFromConfig(iconRefer, KDepth, depth);
+
+ CUPnPIconParams* icon = CUPnPIconParams::NewL ();
+ icon->SetMimeTypeL (typeBuf);
+ icon->SetUrlL (urlBuf);
+ icon->SetWidth (width);
+ icon->SetHeight (height);
+ icon->SetDepth (depth);
+
+ registerDeviceParamSet->SetIconInfoL (icon);
+ typeBuf.Close ();
+ urlBuf.Close ();
+ }while ( GetStringFromConfig(iconRefer, KIconRefer, iconRefer) );
+/*
+ if ( GetStringFromConfig(iconRefer, KIconRefer, iconRefer) )
+ {
+ goto iconRead;
+ }*/
+ }
+
+ registerDeviceParamSet-> SetParentDeviceUidL(parentdeviceuidBuf);
+ registerDeviceParamSet-> SetUriL (devicetypeBuf);
+ registerDeviceParamSet-> SetFriendlyNameL (friendlynameBuf);
+ registerDeviceParamSet-> SetManufacturerL (manufacturerBuf );
+ registerDeviceParamSet-> SetManufactureUrlL (manufacturerurlBuf);
+ registerDeviceParamSet-> SetModelDescL (modeldescriptionBuf);
+ registerDeviceParamSet-> SetModelNameL (modelnameBuf);
+ registerDeviceParamSet-> SetModelNumberL (modelnumberBuf);
+ registerDeviceParamSet-> SetModelUriL (modelurlBuf);
+ registerDeviceParamSet-> SetPresentationL (presentationurlBuf);
+ registerDeviceParamSet-> SetSerialNumberL (serialnumberBuf);
+ registerDeviceParamSet-> SetUDNL (udnBuf);
+ registerDeviceParamSet-> SetUPCL (upcBuf);
+ registerDeviceParamSet-> SetCacheControlData (duration);
+
+ //To keep track of mapping between Observer and Publisher
+ TInt publisherIndex = OpenPublisherL();
+ //Create mapping of Publsiher and observer
+ TPublisherObserverMap publisherObserverMapElement;
+ publisherObserverMapElement.iPublisherIndex = publisherIndex;
+ publisherObserverMapElement.iObserverIndex = observerIndex;
+ publisherObserverMapElement.iPublisherControl = KDevice;
+ iPublisherObserverMap.Append(publisherObserverMapElement);
+
+ //Publish Device and update publish count
+ iPublishCount++;
+ iPublisherArray[publisherIndex].Publish( pnpBundle );
+
+ TBool SchedulerStart = EFalse;
+ _LIT(KSchedulerStart, "schedulerstart");
+ GetBoolFromConfig(aOperationType, KSchedulerStart, SchedulerStart);
+ if(SchedulerStart)
+ {
+ CActiveScheduler::Start();
+ }
+
+ upcBuf.Close();
+ udnBuf.Close();
+ serialnumberBuf.Close();
+ presentationurlBuf.Close();
+ modelurlBuf.Close();
+ modelnumberBuf.Close();
+ modelnameBuf.Close();
+ manufacturerurlBuf.Close();
+ manufacturerBuf.Close();
+ friendlynameBuf.Close();
+ devicetypeBuf.Close();
+ parentdeviceuidBuf.Close();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ _LIT(KInfoLogFile1, "PublishDeviceL End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+Test for Register announcements ssdp:alive and ssdp:byebye messages
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+*/
+void CTestUPnPManager::RegisterForAnnouncementsL (const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "RegisterForAnnouncementsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ RArray uriTypeList;
+ TPtrC listOfUriTypes;
+ _LIT(KListOfUriTypes, "listofuritypes");
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPRegisterAnnouncementParamSet);
+
+ if(!GetStringFromConfig(GetCurrentSection(), KListOfUriTypes, listOfUriTypes))
+ {
+ _LIT(KErrInfo, "Problem in reading values from ini. \n Expected fields are: %S \n");
+ ERR_PRINTF2( KErrInfo, &KListOfUriTypes);
+ return;
+ }
+
+ TokenizeStringL(listOfUriTypes, uriTypeList);
+ TInt numUris = uriTypeList.Count();
+ RBuf8 buf;
+ buf.Create(KMaxUriSize);
+ for(TInt i(0); i < numUris; i++)
+ {
+ CUPnPRegisterAnnouncementParamSet* announcementParamSet = CUPnPRegisterAnnouncementParamSet::NewL( pnpFamily );
+ buf.Copy(uriTypeList[i]);
+ announcementParamSet->SetUriL( buf );
+ }
+ buf.Close();
+ uriTypeList.Close();
+ iControlPoint.RegisterNotify( pnpBundle );
+ TBool schedulerStart = EFalse;
+ _LIT(KSchedulerStart, "schedulerstart");
+ GetBoolFromConfig(aOperationType, KSchedulerStart, schedulerStart);
+ if(schedulerStart)
+ {
+ CActiveScheduler::Start();
+ }
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ _LIT(KInfoLogFile1, "RegisterForAnnouncementsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+
+ }
+
+/*
+ Tests whether subscribtion to event change notifications is performing as specified in UPnP specifications.
+ @param None.
+ @return None.
+ */
+void CTestUPnPManager::SubscribeForStateChangeNotificationsL()
+ {
+ _LIT(KInfoLogFile, "SubscribeForStateChangeNotificationsL() start.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ CleanupStack::PushL( upnpObserver );
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPSubscribeRequestParamSet);
+
+ TInt subscriptionDuration;
+ _LIT(KSubscriptionDuration, "subscriptionduration");
+ GetIntFromConfig(GetCurrentSection(), KSubscriptionDuration, subscriptionDuration);
+ TBool readIni = EFalse;
+ GetBoolFromConfig(GetCurrentSection(), KReadIni, readIni);
+ if(readIni)
+ {
+ CUPnPSubscribeRequestParamSet * subscribeParamSet = CUPnPSubscribeRequestParamSet::NewL (pnpFamily );
+ TPtrC subscriptionUri;
+ GetStringFromConfig(GetCurrentSection(), KSubscriptionUri, subscriptionUri);
+ RBuf8 subscriptionUriBuf;
+ subscriptionUriBuf.Create(subscriptionUri.Length());
+ subscriptionUriBuf.Copy(subscriptionUri);
+ subscribeParamSet->SetDuration(subscriptionDuration);
+ subscribeParamSet->SetUriL(subscriptionUriBuf);
+ subscriptionUriBuf.Close();
+ }
+ else
+ {
+ //Multiple uri's can be submitted for description
+ ResolveAllUrisL();
+ TInt eventUriCount = iEventUriArray.Count();
+ if ( eventUriCount==0 )
+ {
+ _LIT(KEventSubscription,"Event Subscription Cannot be performed \n");
+ INFO_PRINTF1(KEventSubscription);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ //SetTestStepResult(EFail);
+ return;
+ }
+ for(TInt index(0); index < eventUriCount ; index++)
+ {
+ //for (TInt j(0); j < 10 ; j++)
+ //{//Pass Duplicate subscritption reuqest multiple times in single bundle
+ CUPnPSubscribeRequestParamSet * subscribeParamSet = CUPnPSubscribeRequestParamSet::NewL (pnpFamily );
+ subscribeParamSet->SetUriL(iEventUriArray[index]);
+ subscribeParamSet->SetDuration(subscriptionDuration);
+ RBuf eventUri16;
+ eventUri16.Create(iEventUriArray[index].Length());
+ eventUri16.Copy(iEventUriArray[index]);
+ _LIT(KEventSubUriInfo,"Event Uri Submitted for Subscription Request is: %S \n");
+ INFO_PRINTF2(KEventSubUriInfo, &eventUri16);
+ eventUri16.Close();
+ // }
+ }
+ }
+ iControlPoint.Subscribe( pnpBundle );
+ TBool schedulerStart = EFalse;
+ _LIT(KSchedulerStart, "schedulerstart");
+ GetBoolFromConfig(GetCurrentSection(), KSchedulerStart, schedulerStart);
+ if(schedulerStart)
+ {
+ CActiveScheduler::Start();
+ }
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ _LIT(KInfoLogFile1, "SubscribeForStateChangeNotificationsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::ReSubscribeForStateChangeNotificationsL()
+ {
+ _LIT(KInfoLogFile, "Re-SubscribeForStateChangeNotificationsL() start.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ CleanupStack::PushL( upnpObserver );
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPSubscribeRequestParamSet );
+ TInt subscriptionDuration;
+ _LIT(KSubscriptionDuration, "subscriptionduration");
+ GetIntFromConfig(GetCurrentSection(), KSubscriptionDuration, subscriptionDuration);
+
+ TInt eventUriCount = iEventUriArray.Count();
+ if ( eventUriCount==0 )
+ {
+ _LIT(KEventSubscription,"Event Subscription Cannot be performed \n");
+ INFO_PRINTF1(KEventSubscription);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ //SetTestStepResult(EFail);
+ return;
+ }
+ for(TInt index(0); index < eventUriCount ; index++)
+ {
+ CUPnPSubscribeRequestParamSet * subscribeParamSet = CUPnPSubscribeRequestParamSet::NewL (pnpFamily );
+ subscribeParamSet->SetUriL(iEventUriArray[index]);
+ subscribeParamSet->SetDuration(20);
+ RBuf eventUri16;
+ eventUri16.Create(iEventUriArray[index].Length());
+ eventUri16.Copy(iEventUriArray[index]);
+ _LIT(KEventSubUriInfo,"Event Uri Submitted for Re-Subscription is: %S \n");
+ INFO_PRINTF2(KEventSubUriInfo, &eventUri16);
+ eventUri16.Close();
+ }
+ iControlPoint.Subscribe( pnpBundle );
+ CActiveScheduler::Start();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ _LIT(KInfoLogFile1, "Re-SubscribeForStateChangeNotificationsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+/*
+ Tests whether unsubscribtion to subscribed events is performing as specified in UPnP specifications.
+ @param None
+ @return None.
+ */
+void CTestUPnPManager::UnsubscribeForStateChangeNotificationsL(const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "UnsubscribeForStateChangeNotificationsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPCancelSubscribeParamSet);
+
+ TBool readIni = EFalse;
+ GetBoolFromConfig(aOperationType, KReadIni, readIni);
+ if(readIni)
+ {
+ CUPnPCancelSubscribeParamSet * unsubscribeParamSet = CUPnPCancelSubscribeParamSet::NewL(pnpFamily);
+ TPtrC unsubscribepath;
+ _LIT(KUnsubscribePath, "unsubscribepath");
+ GetStringFromConfig(aOperationType, KUnsubscribePath, unsubscribepath);
+ RBuf8 unsubscribepathBuf;
+ unsubscribepathBuf.Create(unsubscribepath.Length());
+ unsubscribepathBuf.Copy(unsubscribepath);
+ unsubscribeParamSet->SetUriL(unsubscribepathBuf);
+ _LIT(KCanCelSubscribeInfo,"Executing Cancel Subscribe for URI: %S \n");
+ INFO_PRINTF2(KCanCelSubscribeInfo, &unsubscribepath);
+
+ iControlPoint.Cancel( pnpBundle );
+ unsubscribepathBuf.Close();
+ }
+ else
+ {
+ TInt eventUriCount = iEventUriArray.Count();
+ if ( eventUriCount==0 )
+ {
+ _LIT(KEventUnSubscription,"Event UnSubscription Cannot be performed \n");
+ INFO_PRINTF1(KEventUnSubscription);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ return;
+ }
+ for(TInt index(0); index < eventUriCount ; index++)//eventUriCount
+ {
+ CUPnPCancelSubscribeParamSet * unsubscribeParamSet = CUPnPCancelSubscribeParamSet::NewL(pnpFamily);
+ unsubscribeParamSet ->SetUriL(iEventUriArray[index]);
+ RBuf eventUri16;
+ eventUri16.Create(iEventUriArray[index].Length());
+ eventUri16.Copy(iEventUriArray[index]);
+ _LIT(KEventSubUriInfo,"Event Uri Submitted for UnSubscription Request is: %S \n");
+ INFO_PRINTF2(KEventSubUriInfo, &eventUri16);
+ eventUri16.Close();
+ }iControlPoint.Cancel( pnpBundle );
+
+ }
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ _LIT(KInfoLogFile1, "UnsubscribeForStateChangeNotificationsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Test for Intiatting a Control Action from Control Point side
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+void CTestUPnPManager::InitiateActionL(const TDesC& /* aOperationType */)
+ {
+ _LIT(KInfoLogFile, "InitiateActionL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ ResolveAllUrisL();
+ if(!iAction)
+ {
+ iAction= CAction::NewL(this);
+ }
+ for(TInt i(0); i < iControlUriArray.Count(); i++)
+ {
+ RBuf controlUri16;
+ controlUri16.Create(iControlUriArray[i].Length());
+ controlUri16.Copy(iControlUriArray[i]);
+ _LIT(KContolUri, "Control Uri Submitted is: %S ");
+ INFO_PRINTF2(KContolUri, &controlUri16);
+ iAction->InitiateActionControlL(iControlUriArray[i],iControlPoint);
+ controlUri16.Close();
+ }
+ _LIT(KInfoLogFile1, "InitiateActionL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Test for Cancelling Discovery Operation
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+void CTestUPnPManager::CancelDiscoverL(const TDesC& aOperationType)
+ {
+ iCancelDiscovery = ETrue;
+ const TInt KBufLength = 1000;
+ _LIT(KInfoLogFile, "CancelDiscoverL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPCancelDiscoverParamSet);
+
+ CUPnPCancelDiscoverParamSet* cancelDiscoverParamSet = CUPnPCancelDiscoverParamSet::NewL(pnpFamily );
+ TPtrC serviceType;
+ GetStringFromConfig(aOperationType, KServiceType, serviceType);
+ _LIT(KCanCelDiscoveryInfo,"Executing Cancel Discovery for URI: %S \n");
+ INFO_PRINTF2(KCanCelDiscoveryInfo, &serviceType);
+ RBuf8 buf;
+ buf.Create(KBufLength);
+ buf.Copy(serviceType);
+ cancelDiscoverParamSet->SetUriL( buf );
+ iControlPoint.Cancel ( pnpBundle );
+ buf.Close();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+
+ TBool flag=ETrue;
+ _LIT(KStopScheduler,"stopscheduler");
+ GetBoolFromConfig(aOperationType,KStopScheduler,flag);
+ if(flag)
+ {
+ CActiveScheduler::Stop();
+ }
+ _LIT(KInfoLogFile1, "CancelDiscoverL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::CancelDescribeL(const TDesC& aOperationType)
+ {
+ //Modify this later
+ const TInt KBufLength = 1000;
+ _LIT(KInfoLogFile, "CancelDescribeL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPCancelDescribeParamSet);
+
+ CUPnPCancelDescribeParamSet* cancelDescribeParamSet = CUPnPCancelDescribeParamSet::NewL( pnpFamily );
+ TPtrC serviceType;
+ GetStringFromConfig(aOperationType, KServiceType, serviceType);
+ _LIT(KCanCelDiscoveryInfo,"Executing Cancel Describe for URI: %S \n");
+ INFO_PRINTF2(KCanCelDiscoveryInfo, &serviceType);
+ RBuf8 buf;
+ buf.Create(KBufLength);
+ buf.Copy(serviceType);
+ cancelDescribeParamSet->SetUriL( buf );
+ iControlPoint.Cancel ( pnpBundle );
+ buf.Close();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ _LIT(KInfoLogFile1, "CancelDescribeL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ Cancells all persistent Device Description Requests.
+*/
+void CTestUPnPManager::CancelAllDeviceDescribeL()
+ {
+ _LIT(KInfoLogFile, "CancelAllDeviceDescribeL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ //this perofrms only Cancellation of all Device descriptions only
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPCancelDescribeParamSet);
+ TInt DevLocCount = iDeviceLocationArray.Count();
+ for(TInt index(0); index < DevLocCount ; index++)
+ {
+ TBuf8<256> url;
+ TUriParser8 uri;
+ uri.Parse(iDeviceLocationArray[index]);
+ url.Copy(_L8("http://"));
+ const TDesC8& scheme = uri.Extract(EUriScheme);
+ _LIT8(KScheme, "http");
+ //Uri must be of scheme "http" only
+ if (scheme.CompareF(KScheme) == 0)
+ {
+ const TDesC8& host = uri.Extract(EUriHost);
+ url.Append(host);
+ url.Append(_L8(":"));
+ const TDesC8& portStr = uri.Extract ( EUriPort );
+ url.Append(portStr);
+ url.Append(_L8("/")) ;
+ CUPnPCancelDescribeParamSet* cancelDescribeParamSet = CUPnPCancelDescribeParamSet::NewL(pnpFamily );
+ cancelDescribeParamSet->SetUriL(url);
+ RBuf uri16;
+ uri16.Create(url.Length());
+ uri16.Copy(url);
+ _LIT(KCanCelDescribeInfo,"Executing Cancel Describe for URI: %S \n");
+ INFO_PRINTF2(KCanCelDescribeInfo, &uri16);
+ uri16.Close();
+ }
+ }
+ iControlPoint.Cancel ( pnpBundle );
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile1, "CancelAllDeviceDescribeL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ }
+
+/*
+ * this perofrms only Cancellation of all Service descriptions only
+*/
+void CTestUPnPManager::CancelAllServiceDescribeL()
+ {
+ _LIT(KInfoLogFile, "CancelAllServiceDescribeL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPCancelDescribeParamSet);
+ TInt scpdCount = iScpdUriArray.Count();
+ for(TInt index(0); index < scpdCount ; index++)
+ {
+ RBuf uri16;
+ uri16.Create(iScpdUriArray[index].Length());
+ uri16.Copy(iScpdUriArray[index]);
+ _LIT(KCanCelDescribeServiceInfo,"Executing Cancel DescribeService for URI: %S \n");
+ INFO_PRINTF2(KCanCelDescribeServiceInfo, &uri16);
+ uri16.Close();
+ CUPnPCancelDescribeParamSet* cancelDescribeParamSet = CUPnPCancelDescribeParamSet::NewL(pnpFamily );
+ cancelDescribeParamSet->SetUriL(iScpdUriArray[index]);
+ }
+ iControlPoint.Cancel ( pnpBundle );
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile1, "CancelAllServiceDescribeL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ }
+
+/*
+ Test for Cancelling Register Announcement
+ @param aOperationType is reference to a section name in ini file where required parameters
+ needs to be referred for this operation.
+ @return None.
+ */
+void CTestUPnPManager::CancelNotifyAnnouncementL(const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "CancelNotifyAnnouncementL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ iObserverArray.Append(upnpObserver);
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL ( EUPnPCancelRegisterNotifyParamSet );
+
+ CUPnPCancelRegisterNotifyParamSet * cancelNotifyParamSet = CUPnPCancelRegisterNotifyParamSet::NewL(pnpFamily);
+ TPtrC uri;
+ GetStringFromConfig(aOperationType, KUri, uri);
+ RBuf8 buf;
+ buf.Create(uri.Length());
+ buf.Copy(uri);
+ cancelNotifyParamSet->SetUriL(buf);
+ iControlPoint.Cancel ( pnpBundle);
+ buf.Close();
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ _LIT(KInfoLogFile1, "CancelNotifyAnnouncementL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::AppendBundlesL(RPnPParameterBundleBase& aPnPBundle)
+ {
+ iResultsArray.AppendL(aPnPBundle);
+ }
+
+/*
+ Validates the discovery response received from the callback against the expected discovery response.
+ @param aIndex is an integer refers to an index in the ResultsArray of CResults object.
+ @param aResultsList is an array for section names for expected results section.
+ @param aExpctedResults is an array of Bools and each of the element indicates whether the expected results
+ in each section are matched against actual results.
+ @return None
+ */
+
+void CTestUPnPManager::PrintAndValidateResultsL(const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "PrintAndValidateResultsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt resultsCount = 0;
+ const TInt bundleCount = iResultsArray.Count();
+ _LIT(KPrintStatement, "printing results \n");
+ _LIT(KPrintDesign," \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n");
+ INFO_PRINTF1(KPrintStatement);
+ INFO_PRINTF1(KPrintDesign);
+ for(TInt i(0); i < bundleCount; i++)
+ {
+ RParameterFamily paramFamily = iResultsArray[i].GetFamilyAtIndex(0);
+ if( !paramFamily.IsNull() )
+ {
+ switch ( paramFamily.Id() )
+ {
+ case EUPnPDiscoverResponseParamSet:
+ {
+ PrintDiscoveryResultsL(paramFamily);
+ ValidateDiscoveryResultsL(aOperationType);
+ }
+ break;
+
+ case EUPnPPresenceAnnouncementParamSet:
+ {
+ CUPnPPresenceAnnouncementParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+
+ //Paramset at current position
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KRegisterAliveFailed,"Failed to Send Register Alive Notifications with...Error Code = %d \n");
+ ERR_PRINTF2(KRegisterAliveFailed, error);
+ //SetTestStepResult(EFail);
+ continue;
+ }
+ TPtrC8 serviceLocation(paramSet->ServiceLocation());
+ HBufC* devloc = HBufC::NewLC(serviceLocation.Length()); //1
+ devloc->Des().Copy(serviceLocation);
+ TPtrC devLocPointer (devloc->Des());
+ _LIT(KInfoUri,"The URI found is %S \n");
+ INFO_PRINTF2(KInfoUri, &devLocPointer);
+
+ TInt availabilityDuration = 0;
+ availabilityDuration = paramSet->Duration();
+ _LIT(KInfoDuration,"The service availability duration is %d \n");
+ INFO_PRINTF2(KInfoDuration, &availabilityDuration);
+
+ _LIT(KInfoAlive,"ssdp:alive notification got from %S AND Duration is %d\n");
+ INFO_PRINTF3(KInfoAlive, &devLocPointer, &availabilityDuration);
+
+ TPtrC8 usn(paramSet->USN());
+ HBufC* usnVal = HBufC::NewLC(usn.Length()); //2
+ usnVal->Des().Copy(usn);
+ TPtrC usnValPointer (usnVal->Des());
+ _LIT(KInfoUSN,"The USN found is %S \n");
+ INFO_PRINTF2(KInfoUSN, &usnValPointer);
+
+ TPtrC8 uri(paramSet->Uri());
+ HBufC* uriVal = HBufC::NewLC(uri.Length()); //3
+ uriVal->Des().Copy(uri);
+ TPtrC uriValPointer (uriVal->Des());
+ _LIT(KInfoURI,"The Uri found is %S \n");
+ INFO_PRINTF2(KInfoURI, &uriValPointer);
+ resultsCount++;
+ CleanupStack::PopAndDestroy(uriVal);
+ CleanupStack::PopAndDestroy(usnVal);
+ CleanupStack::PopAndDestroy(devloc);
+ }
+ }
+ break;
+ case EUPnPDescribeResponseParamSet:
+ {
+ CUPnPDescribeResponseParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KDescribeFailed,"Failed to Describe with...Error Code = %d \n");
+ ERR_PRINTF2(KDescribeFailed, error);
+ //SetTestStepResult(EFail);
+ return;
+ }
+ TPtrC8 description(paramSet->Description());
+ HBufC* descriptionValue = HBufC::NewLC(description.Length());
+ descriptionValue->Des().Copy(description);
+ TPtrC descriptionPointer (descriptionValue->Des());
+ _LIT(KInfoDescribe,"content is %S \n");
+ INFO_PRINTF2(KInfoDescribe, &descriptionPointer);
+ CleanupStack::PopAndDestroy(descriptionValue);
+ resultsCount++;
+ }
+ //Reached Eof the Bundles
+ }
+ break;
+ case EUPnPAbsenceAnnouncementParamSet:
+ {
+ CUPnPAbsenceAnnouncementParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast (paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+ //Paramset at current position
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KRegisterByeByeFailed,"Failed to Send Register ByeBye Notifications with...Error Code = %d \n");
+ ERR_PRINTF2(KRegisterByeByeFailed, error);
+ //SetTestStepResult(EFail);
+ continue;
+ }
+ TPtrC8 usn(paramSet->USN());
+ HBufC* usnVal = HBufC::NewLC(usn.Length());
+ usnVal->Des().Copy(usn);
+ TPtrC usnValPointer (usnVal->Des());
+
+ _LIT(KInfoBye,"ssdp:byebye notification received from %S \n");
+ INFO_PRINTF2(KInfoBye, &usnValPointer);
+ resultsCount++;
+ CleanupStack::PopAndDestroy(usnVal);
+ }
+ }
+ break;
+ case EUPnPSubscribeResponseParamSet:
+ {
+
+ CUPnPSubscribeResponseParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast (paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+ RBuf subscriptionUri16;
+ subscriptionUri16.Create(paramSet->Uri().Length());
+ subscriptionUri16.Copy(paramSet->Uri());
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ _LIT(KInfoSubscribeFailed, "Err: Failed to Subscribe.\n %S \n");
+ INFO_PRINTF2(KInfoSubscribeFailed,&subscriptionUri16);
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KErrSubscribe,"Failed to Subscribe with...Error Code = %d \n");
+ ERR_PRINTF2(KErrSubscribe, error);
+ //SetTestStepResult(EFail);
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESubscriptionTimeout)
+ {
+ _LIT(KInfoSubscribeTimedOut, "Info: SubscribeTimed out \n %S \n");
+ INFO_PRINTF2(KInfoSubscribeTimedOut,&subscriptionUri16);
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ _LIT(KInfoSubscribeSuccess, "Info: Subscribtion SUCCESS\n %S \n");
+ INFO_PRINTF2(KInfoSubscribeSuccess,&subscriptionUri16);
+ }
+ subscriptionUri16.Close();
+ }
+ }
+ break;
+ case EUPnPNotifyEventParamSet:
+ {//receives event notifications sent at client
+
+ CUPnPNotifyEventParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast (paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+ RBuf subscriptionUri16;
+ subscriptionUri16.Create(paramSet->Uri().Length());
+ subscriptionUri16.Copy(paramSet->Uri());
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ _LIT(KInfoNotificationsFailed, "Err: Failed to Get Event notifications \n %S \n");
+ INFO_PRINTF2(KInfoNotificationsFailed,&subscriptionUri16);
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KNotificationsFailed,"Failed to Receive Notifications with...Error Code = %d \n");
+ ERR_PRINTF2(KNotificationsFailed, error);
+ //SetTestStepResult(EFail);
+ }
+ else if (paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ _LIT(KInfoNotifications, "Notifications for subscribed Uri: %S \t is received \n");
+ INFO_PRINTF2(KInfoNotifications, &subscriptionUri16);
+ }
+ subscriptionUri16.Close();
+ }
+ }
+ break;
+ default:
+ {
+ //Do Nothing
+ }
+ break;
+ }
+ }
+ }
+ _LIT(KEndPrintStatement,"Done with printing results \n");
+ INFO_PRINTF1(KEndPrintStatement);
+ INFO_PRINTF1(KPrintDesign);
+ }
+
+/*
+ Constructor:
+*/
+CUPnPObserver::CUPnPObserver()
+ :iSequence(0),iResultsCount(0)
+ {
+ }
+
+/*
+ Destructor
+*/
+CUPnPObserver::~CUPnPObserver()
+ {
+ iFileServ.Close();
+ }
+
+
+/*
+ Static factory constructor. Uses two phase construction and leaves nothing on the
+ CleanupStack. Creates a CTestControlPointService object.
+ @param aManager A pointer to a CTestUPnPManager object.
+ @return A pointer to the newly created CPnPObserver object.
+ @post A fully constructed and initialized CPnPObserver object.
+ */
+CUPnPObserver* CUPnPObserver::NewL(CTestUPnPManager* aManager)
+ {
+ CUPnPObserver* self = new(ELeave) CUPnPObserver;
+ CleanupStack::PushL(self);
+ self->ConstructL(aManager);
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/*
+ Second phase of two-phase construction method. Does any allocations required to fully construct
+ the object.
+ @pre First phase of construction is complete.
+ @param aManager A pointer to a CTestUPnPManager object.
+ @post The object is fully constructed and initialized.
+ */
+void CUPnPObserver::ConstructL(CTestUPnPManager* aManager)
+ {
+ iManager = aManager;
+ User::LeaveIfError(iFileServ.Connect());
+ }
+
+
+
+/*
+ This method returns a reference to the CTestUPnPManager object.
+ @param None
+ return a reference to the CTestUPnPManager object
+ */
+CTestUPnPManager& CUPnPObserver::Manager()
+ {
+ return *iManager;
+ }
+
+/*
+ This is called when callback hits. And this method stores the bundle results
+ and meta information related to that results into results array maintained by manager
+ for later verification.
+ @param aParameterBundle a reference to CPnPParameterBundleBase
+ @return None
+ */
+void CUPnPObserver::OnPnPEventL ( RPnPParameterBundleBase& aParameterBundle)
+ {
+ _LIT(KInfoLogFile, "OnPnPEventL ().... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+
+ CopyResultBundlesL(aParameterBundle);
+ RParameterFamily paramFamily = aParameterBundle.GetFamilyAtIndex(0);
+ TRAPD ( err, paramFamily.CheckOpenL () );
+
+ if( err == KErrNone)
+ {
+ switch ( paramFamily.Id() )
+ {
+ case EUPnPDiscoverResponseParamSet:
+ {
+ CUPnPDiscoverResponseParamSet* paramSet = NULL;
+ _LIT(KDiscoverResponse,"Discover Response is: \n");
+ Manager().INFO_PRINTF1(KDiscoverResponse);
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ //Printig of Search target
+ TPtrC8 uriST(paramSet->Uri());
+ HBufC* stUri = HBufC::NewLC(uriST.Length());
+ stUri->Des().Copy(uriST);
+ TPtrC uriStPtr (stUri->Des());
+ _LIT(KInfoST,"The SerachTarget given was %S \n");
+ Manager().INFO_PRINTF2(KInfoST, &uriStPtr);
+ CleanupStack::PopAndDestroy(stUri);
+
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EDiscoveryTimeout)
+ {
+ _LIT(KDiscoverTimeOut,"Discover Response TimeOut: TUPnPEvent::EDiscoveryTimeout \n");
+ Manager().INFO_PRINTF1(KDiscoverTimeOut);
+
+ _LIT(KInfoLogFile, "EUPnPDiscoverResponseParamSet TimeOut.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ _LIT(KDuplicateUri, "duplicateuri");
+ TBool duplicateUri = EFalse;
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KDuplicateUri,duplicateUri );
+
+ if(duplicateUri)
+ {
+
+ CActiveScheduler::Stop();
+ _LIT(KInfoRetry, "Discovery Success with results.... \n");
+ Manager().INFO_PRINTF1(KInfoRetry);
+ Manager().SetDiscoveryStatus(ETrue);
+ return;
+ }
+
+ //Found valid discovery responses
+ if (Manager().iDeviceLocationArray.Count() > 0)
+ {
+ CActiveScheduler::Stop();
+ _LIT(KInfoRetry, "Discovery Success with results.... \n");
+ Manager().INFO_PRINTF1(KInfoRetry);
+ Manager().SetDiscoveryStatus(ETrue);
+ }
+ else if(Manager().IsDiscoverySuccess() && Manager().iFailedNumUris <= 1)
+ {
+ // Discovery Retry also Failured
+ CActiveScheduler::Stop();
+ _LIT(KInfoFail, "Discovery Failed.... \n");
+ Manager().ERR_PRINTF1(KInfoFail);
+ //Manager().SetTestStepResult(EFail);
+ }
+ else if(Manager().iFailedNumUris >= 1 )
+ {
+ //Retrty Discovery only if and only if All Uri's Timedout
+ Manager().iFailedNumUris--;
+ TInt failedUriCount = Manager().iFailedNumUris;
+ if ( failedUriCount == 0 )
+ {
+ CActiveScheduler::Stop();
+ }
+ _LIT(KInfoRetry, "Waiting responses from %d Uris \n");
+ Manager().INFO_PRINTF2(KInfoRetry, Manager().iFailedNumUris );
+ }
+ return;
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KDiscoverFail,"Discover Response Fail: TUPnPEvent::EFail Error Code is = %d \n");
+ Manager().ERR_PRINTF2(KDiscoverFail, error);
+ CActiveScheduler::Stop();
+ //To eliminate the repetition of Discovery
+ Manager().SetDiscoveryStatus(ETrue);
+ _LIT(KInfoLogFile, "EUPnPDiscoverResponseParamSet EFail.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ //opt for Abrupt close of CP
+ TBool abruptDiscoveryCloseCP = EFalse;
+ _LIT(KAbruptDiscoveryCloseCP,"abruptdiscoveryclosecp");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KAbruptDiscoveryCloseCP,abruptDiscoveryCloseCP );
+ if(abruptDiscoveryCloseCP)
+ {
+ //Closing Control point Abruptly
+ _LIT(KInfoSubScribe, "In Discovery Response \n");
+ _LIT(KInfoCloseCP, "Closing Control point Abruptly....\n");
+ Manager().INFO_PRINTF1(KInfoSubScribe);
+ Manager().INFO_PRINTF1(KInfoCloseCP);
+ CActiveScheduler::Stop();
+ Manager().CloseDiscoverer();
+ return;
+ }
+ //Printing of Loaction
+ TPtrC8 deviceLocation(paramSet->DeviceLocation());
+ HBufC* devloc = HBufC::NewLC(deviceLocation.Length()); //1
+ devloc->Des().Copy(deviceLocation);
+ TPtrC devLocPointer (devloc->Des());
+ _LIT(KInfoUri,"The Location: %S \n");
+ Manager().INFO_PRINTF2(KInfoUri, &devLocPointer);
+ //Storing Device location to array
+ Manager().AppendDeviceLocationL(deviceLocation);
+ TPtrC8 usn(paramSet->USN());
+ HBufC* usnVal = HBufC::NewLC(usn.Length()); //2
+ usnVal->Des().Copy(usn);
+ TPtrC usnValPointer (usnVal->Des());
+ _LIT(KInfoUSN,"The USN found is %S \n");
+ Manager().INFO_PRINTF2(KInfoUSN, &usnValPointer);
+
+ TInt expiryTime = paramSet->ExpiryTime();
+ _LIT(KInfoexpiryTime,"The Expiry Time is %d \n");
+ Manager().INFO_PRINTF2(KInfoexpiryTime, expiryTime);
+ CleanupStack::PopAndDestroy(usnVal);
+ CleanupStack::PopAndDestroy(devloc);
+
+ //Cancel discovery
+ TBool cancelDiscovery= EFalse;
+ _LIT(KCancelDiscover, "canceldiscover");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KCancelDiscover,cancelDiscovery);
+ //Eliminate multiple Cancel Discovery
+ //To not to execute Activescheduler::stop many times
+ if (cancelDiscovery && !Manager().iCancelDiscovery)
+ {
+ TPtrC referSection;
+ _LIT(KReferSection,"refersection");
+ Manager().GetStringFromConfig(Manager().GetCurrentSection(),KReferSection,referSection );
+
+ _LIT(KInfoCancelDiscovery,"Cancel Discovery is executed \n");
+ Manager().INFO_PRINTF1(KInfoCancelDiscovery);
+ Manager().CancelDiscoverL(referSection);
+ //To eliminate the repetition of Discovery
+ Manager().SetDiscoveryStatus(ETrue);
+ }
+ _LIT(KInfoLogFile, "EUPnPDiscoverResponseParamSet Success.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ }
+ }
+ }
+ break;
+ case EUPnPPresenceAnnouncementParamSet:
+ {
+ CUPnPPresenceAnnouncementParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ //Printig of Search target
+ TPtrC8 uriST(paramSet->Uri());
+ HBufC* stUri = HBufC::NewLC(uriST.Length());
+ stUri->Des().Copy(uriST);
+ TPtrC uriStPtr (stUri->Des());
+ _LIT(KInfoST,"The RegisterNotify URI was: %S \n");
+ Manager().INFO_PRINTF2(KInfoST, &uriStPtr);
+ CleanupStack::PopAndDestroy(stUri);
+
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KRegisterNotifyFail,"Resgitser Notify Failed: TUPnPEvent::EFail Error Code is = %d \n");
+ Manager().ERR_PRINTF2(KRegisterNotifyFail,error);
+ CActiveScheduler::Stop();
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ TPtrC8 serviceLocation(paramSet->ServiceLocation());
+ HBufC* servloc = HBufC::NewLC(serviceLocation.Length()); //1
+ servloc->Des().Copy(serviceLocation);
+ TPtrC servlocPointer (servloc->Des());
+ TInt duration = paramSet->Duration();
+ _LIT(KInfoAlive,"ssdp:alive notification got from %S AND Duration is %d \n");
+ iManager->INFO_PRINTF3(KInfoAlive, &servlocPointer, &duration);
+ CleanupStack::PopAndDestroy(servloc);
+ iResultsCount++;
+ }
+ _LIT(KInfoLogFile, "EUPnPPresenceAnnouncementParamSet.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ }
+ break;
+
+ case EUPnPAbsenceAnnouncementParamSet:
+ {
+ CUPnPAbsenceAnnouncementParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ //Printig of Search target
+ TPtrC8 uriST(paramSet->Uri());
+ HBufC* stUri = HBufC::NewLC(uriST.Length());
+ stUri->Des().Copy(uriST);
+ TPtrC uriStPtr (stUri->Des());
+ _LIT(KInfoST,"The RegisterNotify URI was: %S \n");
+ Manager().INFO_PRINTF2(KInfoST, &uriStPtr);
+ CleanupStack::PopAndDestroy(stUri);
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KRegisterNotifyByeByeFail,"Resgitser Notify ByeBye Failed: TUPnPEvent::EFail Error Code is = %d \n");
+ Manager().ERR_PRINTF2(KRegisterNotifyByeByeFail, error);
+ CActiveScheduler::Stop();
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ TPtrC8 usn(paramSet->USN());
+ HBufC* usnvalue = HBufC::NewLC(usn.Length()); //1
+ usnvalue->Des().Copy(usn);
+ TPtrC usnPointer (usnvalue->Des());
+ _LIT(KInfoBye,"ssdp:byebye notification received from %S \n");
+ iManager->INFO_PRINTF2(KInfoBye, &usnPointer);
+ CleanupStack::PopAndDestroy(usnvalue);
+ }
+ _LIT(KInfoLogFile, "EUPnPAbsenceAnnouncementParamSet.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ }
+ break;
+
+ case EUPnPPublishResponseParamSet:
+ {
+ TBool flag=EFalse;
+ _LIT(KStopScheduler,"stopscheduler");
+ TInt responseCount = 0;
+ CUPnPPublishResponseParamSet* paramSet = NULL;
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KStopScheduler,flag);
+ _LIT(KExpectedPublishEesponseCount,"expectedpublishresponsecount");
+ Manager().GetIntFromConfig(Manager().GetCurrentSection(),KExpectedPublishEesponseCount,responseCount);
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ Manager().iPublishCount--;
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ TBool sendNotify= EFalse;
+ TInt notifyCount(0);
+ _LIT(KInfoPublish, "Info: Succesfully Published a Device/Service.");
+ Manager().INFO_PRINTF1(KInfoPublish);
+ _LIT(KSendNotify,"sendnotifications");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KSendNotify,sendNotify);
+
+ if(sendNotify)
+ {
+ RBuf16 descriptionBaseUri;
+ descriptionBaseUri.Create(paramSet->Uri().Length());
+ descriptionBaseUri.Copy(paramSet->Uri());
+ _LIT(KInfoSendNotify, "Info: Calling Send Notify on Uri %S \n");
+ Manager().INFO_PRINTF2(KInfoSendNotify, &descriptionBaseUri);
+ descriptionBaseUri.Close();
+ Manager().SendNotificationsL(this);
+ }
+ _LIT(KExpctedNotifications,"expectednotifications");
+ Manager().GetIntFromConfig(Manager().GetCurrentSection(),KExpctedNotifications,notifyCount);
+ TInt publishCount = Manager().iPublishCount;
+ if(flag && notifyCount == Manager().NotifyCount()&& publishCount <= 0 )
+ {
+ _LIT(KInfoLogFile, "EUPnPPublishResponseParamSet Success....And Stopping Active Scheduler after %d Publishes \n");
+ Manager().INFO_PRINTF2(KInfoLogFile, publishCount );
+ CActiveScheduler::Stop();
+ }
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KErrPublish,"Failed to Published a Device/Service...Error Code is = %d \n");
+ Manager().ERR_PRINTF2(KErrPublish, error);
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "EUPnPPublishResponseParamSet Fail.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ }
+ }
+ break;
+
+ case EUPnPDescribeResponseParamSet:
+ {
+ //abruptdescribeclosecp
+ //opt for Abrupt close of CP
+ TBool abruptDiscribeCloseCP = EFalse;
+ _LIT(KAbruptDiscribeCloseCP,"abruptdescribeclosecp");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KAbruptDiscribeCloseCP,abruptDiscribeCloseCP );
+ if(abruptDiscribeCloseCP)
+ {
+ //Closing Control point Abruptly
+ _LIT(KInfoSubScribe, "In Describe Response \n");
+ _LIT(KInfoCloseCP, "Closing Control point Abruptly.... \n");
+ Manager().INFO_PRINTF1(KInfoSubScribe);
+ Manager().INFO_PRINTF1(KInfoCloseCP);
+ CActiveScheduler::Stop();
+ Manager().CloseDiscoverer();
+ return;
+ }
+
+
+ CUPnPDescribeResponseParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ //Only one response expected for Describe and no iter increment is required
+ //Paramset at current position
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ RBuf8 descriptionBuf;
+ RBuf8 descriptionBaseUri;
+ descriptionBaseUri.Create(paramSet->Uri());
+ descriptionBuf.Create(paramSet->Description());
+
+ RBuf description16;
+ description16.Create(descriptionBuf.Length());
+ description16.Copy(descriptionBuf);
+
+ RBuf descriptionUri16;
+ descriptionUri16.Create(descriptionBaseUri.Length());
+ descriptionUri16.Copy(descriptionBaseUri);
+
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KDescribeFail,"Describe Response Fail: TUPnPEvent::EFail...Error Code is = %d \n");
+ Manager().ERR_PRINTF2(KDescribeFail, error);
+ _LIT(KDescriptionUri,"Description Uri is %S \n");
+ Manager().ERR_PRINTF1(KDescribeFail);
+ Manager().INFO_PRINTF2(KDescriptionUri, &descriptionUri16 );
+ _LIT(KInfoLogFile, "EUPnPDescribeResponseParamSet Fail.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ CActiveScheduler::Stop();
+ descriptionBuf.Close();
+ descriptionBaseUri.Close();
+ description16.Close();
+ descriptionUri16.Close();
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ Manager().AppendDescriptionL(descriptionBaseUri, descriptionBuf);
+ TFileName filename;
+ filename.Format(KDefaultFileFormat, 'C');
+ TBuf filenameBuffer(filename);
+ //get scriptName
+ filenameBuffer.Append(Manager().ScriptFileName());
+ _LIT(KUnderScore, "_");
+ filenameBuffer.Append(KUnderScore);
+ filenameBuffer.AppendNumFixedWidth(iSequence,EDecimal, 4);
+ iSequence++;
+ filenameBuffer.Append(KDefaultExtension);
+ RFile file;
+ TInt err=file.Replace(iFileServ,filenameBuffer,EFileRead|EFileWrite|EFileShareAny);
+ if (err == KErrNone)
+ {
+ TInt writeErr= file.Write(descriptionBuf);
+ if(writeErr != KErrNone )
+ {
+ _LIT(KErrWrite,"Unable to Write the description to the File \n");
+ Manager().ERR_PRINTF1(KErrWrite);
+ }
+ _LIT(KDescriptionUri,"Description Uri is %S \n");
+ _LIT(KInfoDescribe,"content is %S \n");
+ Manager().INFO_PRINTF2(KDescriptionUri, &descriptionUri16 );
+ Manager().INFO_PRINTF2(KInfoDescribe, &description16);
+ Manager().iDescribeResponseCount++;
+ }
+ descriptionBuf.Close();
+ descriptionBaseUri.Close();
+ description16.Close();
+ descriptionUri16.Close();
+ file.Close();
+ iResultsCount++;
+ }
+ TBool cancelAll = EFalse;
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(), KCancelAll, cancelAll );
+ TBool cancelAllService = EFalse;
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(), KCancelAllService, cancelAllService );
+ TInt descCount = 1;
+ Manager().GetIntFromConfig(Manager().GetCurrentSection(), KExpctedDescriptions, descCount );
+
+ if(Manager().iDescribeResponseCount >= descCount )// Modify this later
+ {
+ if(cancelAll)
+ {
+ Manager().CancelAllDeviceDescribeL();
+ return;
+ }
+ else if(cancelAllService)
+ {
+ Manager().CancelAllServiceDescribeL();
+ return;
+ }
+ else
+ {
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "EUPnPDescribeResponseParamSet.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ return;
+ }
+ }
+ }
+ break;
+ case EUPnPSubscribeResponseParamSet:
+ {
+
+ CUPnPSubscribeResponseParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ //Paramset at current position
+ RBuf subscriptionUri16;
+ subscriptionUri16.Create(paramSet->Uri().Length());
+ subscriptionUri16.Copy(paramSet->Uri());
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ _LIT(KInfoSubscribeFailed, "Info: Failed to Subscribe.\n %S \n");
+ Manager().INFO_PRINTF2(KInfoSubscribeFailed,&subscriptionUri16);
+ subscriptionUri16.Close();
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KSubscribeFailed,"Failed to Subscribe with...Error Code = %d \n");
+ Manager().ERR_PRINTF2(KSubscribeFailed, error);
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "EUPnPSubscribeResponseParamSet Fail.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESubscriptionTimeout)
+ {
+ _LIT(KInfoSubscribeTimeOut, "Info: Subscription about to expire\n %S \n");
+ Manager().INFO_PRINTF2(KInfoSubscribeTimeOut, &subscriptionUri16);
+ subscriptionUri16.Close();
+ _LIT(KInfoSubscribeTimeOut3, "subscription uri deleted\n");
+ Manager().INFO_PRINTF1(KInfoSubscribeTimeOut3);
+
+ //Implementation of Resubscribe is here
+ TBool renewFlag = EFalse;
+ _LIT(KRenewFlag,"renewflag");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KRenewFlag,renewFlag );
+
+ _LIT(KInfoSubscribeTimeOut1, "renew flag value %d renew count %d \n");
+ Manager().INFO_PRINTF3(KInfoSubscribeTimeOut1, renewFlag,Manager().iRenewCount);
+
+ RDebug::Print( _L( "checked ini to subscribe or resubscribe" ));
+
+ if( renewFlag && Manager().iRenewCount == 0)
+ {//go to renew here only once
+ RDebug::Print( _L( "Go to renew here - Stopping Scheduler" ));
+ subscriptionUri16.Close();//cleanup activity
+ CActiveScheduler::Stop();//this is for start made in prev subscribe
+ _LIT(KInfoLogFile, "EUPnPSubscribeResponseParamSet Timeout1.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ Manager().iRenewCount++;
+ //renew subscriptions
+ _LIT(KInfoSubscribeTimeOut2, "renew count %d \n");
+ Manager().INFO_PRINTF2(KInfoSubscribeTimeOut2,Manager().iRenewCount);
+ _LIT(KInfoReSubscribe, "Request to RESUBSCRIPTION is Executed\n");
+ Manager().INFO_PRINTF1(KInfoReSubscribe);
+ Manager().SubscribeForStateChangeNotificationsL();
+ return;
+ }
+ else
+ {
+ //Unsubscribe before closing
+ RDebug::Print( _L( "Unsubscribe before closing" ));
+ _LIT(KInfoUnSubscribe, "Request to UNSUBSCRIPTION is Executed As Subscription TIMED OUT \n");
+ Manager().INFO_PRINTF1(KInfoUnSubscribe);
+ TPtrC referSection;
+ _LIT(KReferSection,"refersection");
+ Manager().GetStringFromConfig(Manager().GetCurrentSection(),KReferSection,referSection );
+ RDebug::Print( _L( "Before calling UnsubscribeForStateChangeNotificationsL" ));
+ Manager().UnsubscribeForStateChangeNotificationsL(referSection);
+ RDebug::Print( _L( "After calling UnsubscribeForStateChangeNotificationsL" ));
+ subscriptionUri16.Close();//cleanup activity
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "EUPnPSubscribeResponseParamSet Timeout2.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ return;
+ }
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ _LIT(KInfoSubscribeSuccess, "Info: SUBSCRIPTION REQUEST IS ACCEPTED FOR SUBSCRIPTION\n %S \n");
+ Manager().INFO_PRINTF2(KInfoSubscribeSuccess, &subscriptionUri16);
+
+ //opt for Abrupt close of CP
+ TBool abruptCloseCP = EFalse;
+ _LIT(KAbruptCloseCP,"abruptclosecp");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KAbruptCloseCP,abruptCloseCP );
+ if(abruptCloseCP)
+ {
+ //Closing Control point Abruptly
+ _LIT(KInfoSubScribe, "In Subscribe Response \n");
+ _LIT(KInfoCloseCP, "Closing Control point Abruptly.... \n");
+ Manager().INFO_PRINTF1(KInfoSubScribe);
+ Manager().INFO_PRINTF1(KInfoCloseCP);
+ CActiveScheduler::Stop();
+ Manager().CloseDiscoverer();
+ return;
+ }
+ //Opt for Unsubscribe
+ TBool unSubscribeFlag = EFalse;
+ _LIT(KUnsubscribeFlag,"unsubscribeflag");
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(),KUnsubscribeFlag,unSubscribeFlag );
+ if ( Manager().iRenewCount > 0 )
+ {
+ TPtrC referSection;
+ _LIT(KReferSection,"refersection");
+ Manager().GetStringFromConfig(Manager().GetCurrentSection(),KReferSection,referSection );
+ Manager().GetBoolFromConfig(referSection,KUnsubscribeFlag,unSubscribeFlag );
+ if ( unSubscribeFlag )
+ {
+ _LIT(KInfoUnSubscribe, "Request to UNSUBSCRIPTION is Executed After Renew Subscription Success\n \n");
+ Manager().INFO_PRINTF1(KInfoUnSubscribe);
+ }
+ }
+ if(unSubscribeFlag)
+ {//go to unsubscribe here
+ _LIT(KInfoUnSubscribe, "Request to UNSUBSCRIPTION is Executed Before Subscription Expiry\n \n");
+ Manager().INFO_PRINTF1(KInfoUnSubscribe);
+ TPtrC referSection;
+ _LIT(KReferSection,"refersection");
+ Manager().GetStringFromConfig(Manager().GetCurrentSection(),KReferSection,referSection );
+ //Unsubscribe
+ Manager().UnsubscribeForStateChangeNotificationsL(referSection);
+ subscriptionUri16.Close();//cleanup activity
+ CActiveScheduler::Stop();//this is for start made in prev subscribe
+ _LIT(KInfoLogFile, "EUPnPSubscribeResponseParamSet Success.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+ return;
+ }
+ else
+ {
+
+ RDebug::Print( _L("Not going to unsubscribe,waiting for timeout Notifications"));
+ }
+
+ }
+ }
+ }
+ break;
+ case EUPnPNotifyEventParamSet:
+ {//receives event notifications sent at client
+ _LIT(KInfoLogFile, "EUPnPNotifyEventParamSet.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+
+
+ CUPnPNotifyEventParamSet* paramSet = NULL;
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast ( paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );
+ //Paramset at current position
+
+ RBuf subscriptionUri16;
+ subscriptionUri16.Create(paramSet->Uri().Length());
+ subscriptionUri16.Copy(paramSet->Uri());
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ _LIT(KInfoNotificationsFailed, "Info: Failed to Get Event notifications\n %S \n");
+ Manager().INFO_PRINTF2(KInfoNotificationsFailed,&subscriptionUri16);
+ subscriptionUri16.Close();
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KNotificationsFailed,"Failed to Receive Notifications with...Error Code = %d \n");
+ Manager().ERR_PRINTF2(KNotificationsFailed, error);
+ //Manager().SetTestStepResult(EFail);
+ return;
+ }
+ else if (paramSet->UPnPEvent().iStatus == TUPnPEvent::ESuccess)
+ {
+ _LIT(KInfoNotifications, "Notifications for subscribed Uri: %S \t is received \n");
+ Manager().INFO_PRINTF2(KInfoNotifications, &subscriptionUri16);
+ subscriptionUri16.Close();//cleanup activity
+ }
+ }
+ _LIT(KInfoLogFile1, "EUPnPNotifyEventParamSet End.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile1);
+ }
+ break;
+ default:
+ {
+ //Do Nothing
+ }
+ break;
+ }
+ }
+ }
+
+/*
+ Error handling,asynchronous one.
+ @param aError Error Code
+ @return None
+ */
+void CUPnPObserver::OnPnPError(TInt aError)
+ {
+ _LIT(KPositiveCase,"positivecase");
+ TBool positiveCase = ETrue;
+ Manager().GetBoolFromConfig(Manager().GetCurrentSection(), KPositiveCase, positiveCase);
+ // Note down the error and stop scheduler
+ //If not postive case, client.dll will come back before active scheduler start
+ //so, don't execute activescheduler::stop
+ if (positiveCase)
+ {
+ CActiveScheduler::Stop();
+ }
+ _LIT(KErrorMessage, "Error occurred in the UPnP Observer : %d \n");
+ Manager().ERR_PRINTF2(KErrorMessage, aError);
+ //Manager().SetTestStepResult(EFail);
+ }
+
+/*
+ This function copies result bundles into results array, which inturn is used in printing results
+ @param aPnpBundle a reference to CPnPParameterBundleBase
+ @return None
+ */
+void CUPnPObserver::CopyResultBundlesL(const RPnPParameterBundleBase& aPnpBundle)
+ {
+ _LIT(KInfoLogFile, "CUPnPObserver::CopyResultBundlesL().... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile);
+
+ HBufC8* holdBundle = HBufC8::NewLC(aPnpBundle.Length());
+
+ if (!holdBundle)
+ {
+ User::Leave(KErrNoMemory);
+ }
+
+ TPtr8 storePtr(holdBundle->Des());
+ TInt retOnStore = aPnpBundle.Store(storePtr);
+ User::LeaveIfError(retOnStore);
+
+ TPtrC8 loadPtr(holdBundle->Des());
+ RPnPParameterBundleBase newPnpBundle;
+ newPnpBundle.CreateL();
+ TInt retOnLoad = newPnpBundle.Load(loadPtr);
+ User::LeaveIfError(retOnLoad);
+ CleanupStack::PushL( &newPnpBundle);
+ Manager().AppendBundlesL(newPnpBundle);
+ CleanupStack::Pop(&newPnpBundle);
+ CleanupStack::PopAndDestroy(holdBundle);
+ _LIT(KInfoLogFile1, "CUPnPObserver::CopyResultBundlesL() End.... \n");
+ Manager().INFO_PRINTF1(KInfoLogFile1);
+ }
+
+/*
+ This function Prints Discovery results by getting it from Results bundle
+ @param aParamFamily a pointer to CUPnPParameterFamily
+ @return None
+ */
+void CTestUPnPManager::PrintDiscoveryResultsL(RParameterFamily& aParamFamily)
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::PrintDiscoveryResultsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ _LIT(KPrintStatement, "printing results \n");
+ _LIT(KPrintDesign," \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\ \n");
+
+ INFO_PRINTF1(KPrintStatement);
+ INFO_PRINTF1(KPrintDesign);
+
+ TUint count = aParamFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+ CUPnPDiscoverResponseParamSet* paramSet = NULL;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast(aParamFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KDiscoverFailed,"Failed to Discover with...Error Code = %d \n");
+ ERR_PRINTF2(KDiscoverFailed, error);
+ continue;
+ }
+ else if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EDiscoveryTimeout)
+ {
+ _LIT(KDiscoverTimeOut,"Discover Response TimeOut: TUPnPEvent::EDiscoveryTimeout \n");
+ INFO_PRINTF1(KDiscoverTimeOut);
+ continue;
+ }
+ TPtrC8 deviceLocation(paramSet->DeviceLocation());
+ HBufC* devloc = HBufC::NewLC(deviceLocation.Length()); //1
+ devloc->Des().Copy(deviceLocation);
+ TPtrC devLocPointer (devloc->Des());
+ _LIT(KInfoUri,"The Location: %S \n");
+ INFO_PRINTF2(KInfoUri, &devLocPointer);
+
+ TPtrC8 usn(paramSet->USN());
+ HBufC* usnVal = HBufC::NewLC(usn.Length()); //2
+ usnVal->Des().Copy(usn);
+ TPtrC usnValPointer (usnVal->Des());
+ _LIT(KInfoUSN,"The USN found is %S \n");
+ INFO_PRINTF2(KInfoUSN, &usnValPointer);
+
+ TInt expiryTime = paramSet->ExpiryTime();
+ _LIT(KInfoexpiryTime,"The Expiry Time or CACHE-CONTROL: max-age = %d \n");
+ INFO_PRINTF2(KInfoexpiryTime, expiryTime);
+
+ CleanupStack::PopAndDestroy(usnVal);
+ CleanupStack::PopAndDestroy(devloc);
+ continue;
+ }
+ _LIT(KEndPrintStatement,"Done with printing results \n");
+ INFO_PRINTF1(KEndPrintStatement);
+ INFO_PRINTF1(KPrintDesign);
+ }
+
+void CTestUPnPManager::ValidateDiscoveryResultsL(const TDesC& aOperationType)
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::ValidateDiscoveryResultsL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TInt DeviceLocationCount = NULL;
+ TPtrC ExpectedURL;
+ GetStringFromConfig(aOperationType, KExpectedURL, ExpectedURL);
+
+ TInt totalCount(0);
+ GetIntFromConfig(aOperationType, KExpectedCount, totalCount);
+ const TInt bundleCount = iResultsArray.Count();
+
+ for(TInt i(0); i < bundleCount; i++)
+ {
+ RParameterFamily paramFamily = iResultsArray[i].GetFamilyAtIndex(0);
+ if( !paramFamily.IsNull() )
+ {
+ if(paramFamily.Id() ==EUPnPDiscoverResponseParamSet)
+ {
+
+ CUPnPDiscoverResponseParamSet* paramSet = NULL;
+
+ TUint count = paramFamily.CountParameterSets ( RParameterFamily::ERequested ) ;
+
+ for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )
+ {
+ paramSet = static_cast(paramFamily.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ));
+
+ if(paramSet->UPnPEvent().iStatus == TUPnPEvent::EFail)
+ {
+ TInt error = paramSet->UPnPEvent().iErrorCode;
+ _LIT(KDiscoverFailed,"Failed to Discover with...Error Code = %d \n");
+ ERR_PRINTF2(KDiscoverFailed, error);
+ continue;
+ }
+ TPtrC8 deviceLocation(paramSet->DeviceLocation());
+ HBufC* devloc = HBufC::NewLC(deviceLocation.Length());
+ devloc->Des().Copy(deviceLocation);
+ TPtrC devLocPointer (devloc->Des());
+ DeviceLocationCount++;
+ if((ExpectedURL!=KNullDesC) && (ExpectedURL.Compare(devLocPointer) == KErrNone))
+ {
+ SetTestStepResult(EPass);
+ }
+ CleanupStack::PopAndDestroy(devloc);
+ continue;
+ }
+ }
+ }
+ }
+ if((DeviceLocationCount != NULL) &&(DeviceLocationCount == totalCount))
+ {
+ SetTestStepResult(EPass);
+ }
+ _LIT(KInfoLogFile1, "CTestUPnPManager::ValidateDiscoveryResultsL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::CancelPublish()
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::CancelPublish() Begin.... \n");
+ INFO_PRINTF1(KInfoLogFile);
+ TInt count = iPublisherArray.Count();
+ for(TInt i(count - 1); i >= 0 ; i--)
+ {
+ TPublisherControl publisherType = PublisherType(i);
+ _LIT(KInfoCancelLog, "CTestUPnPManager::CancelPublish()...Closing Publisher.... %d\n");
+ INFO_PRINTF2(KInfoCancelLog,i);
+ switch(publisherType)
+ {
+ case KService:
+ {
+ _LIT(KInfoService, "Closing Publisher.... of Type---->SERVICE\n");
+ INFO_PRINTF1(KInfoService);
+ break;
+ }
+ case KDevice:
+ {
+ _LIT(KInfoDevice, "Closing Publisher.... of Type---->DEVICE\n");
+ INFO_PRINTF1(KInfoDevice);
+ break;
+ }
+ default :
+ {
+ _LIT(KInfoErr, "Closing Publisher.... of Type---->InValid\n");
+ ERR_PRINTF1(KInfoErr);
+ break;
+ }
+ }
+ iPublisherArray[i].Close();
+ }
+ _LIT(KInfoLogFile2, "CancelPublish() Array Closed.... \n");
+ INFO_PRINTF1(KInfoLogFile2);
+ iPublisherArray.Close();
+ _LIT(KInfoLogFile3, "CTestUPnPManager::CancelPublish() End.... \n");
+ INFO_PRINTF1(KInfoLogFile3);
+ }
+
+void CTestUPnPManager::DescribeServiceL()
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::DescribeServiceL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ ResolveAllUrisL();
+ TInt scpdUriCount = iScpdUriArray.Count();
+ //__ASSERT_DEBUG ( scpdUriCount > 0, User::Panic (KDescribeTestPanicCategory,KErrNoDescriptionPath ) );
+ if ( scpdUriCount==0 )
+ {
+ _LIT(KDescription,"Description Cannot be performed \n");
+ INFO_PRINTF1(KDescription);
+ //SetTestStepResult(EFail);
+ return;
+ }
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ CleanupStack::PushL( upnpObserver );
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPDescribeRequestParamSet);
+
+ // Read the ScpdUrl from ScpdUri Array
+ //Make sure that Before this Describe Device, and Discovery is executes Succesfully.
+ for(TInt index(0); index < scpdUriCount ; index++)//scpdUriCount
+ {
+ CUPnPDescribeRequestParamSet* describeParamSet = CUPnPDescribeRequestParamSet::NewL (pnpFamily );
+ describeParamSet->SetUriL(iScpdUriArray[index]);
+ RBuf scpdUri16;
+ scpdUri16.Create(iScpdUriArray[index].Length());
+ scpdUri16.Copy(iScpdUriArray[index]);
+ _LIT(KScpdUriInfo,"SCPD Uri Submitted for Description Request is: %S \n");
+ INFO_PRINTF2(KScpdUriInfo, &scpdUri16);
+ scpdUri16.Close();
+ }
+ iControlPoint.Describe( pnpBundle );
+ CActiveScheduler::Start();
+ _LIT(KInfoLogFile1, "CTestUPnPManager::DescribeServiceL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ }
+
+void CTestUPnPManager::DescribeIconL()
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::DescribeIconL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ ResolveAllUrisL();
+ TInt uriCount = iIconUriArray.Count();
+ if ( uriCount==0 )
+ {
+ _LIT(KIconDescription,"Description Cannot be performed \n");
+ INFO_PRINTF1(KIconDescription);
+ return;
+ }
+
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ CleanupStack::PushL( upnpObserver );
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPDescribeRequestParamSet);
+
+ //Make sure that Before this Describe Device, and Discovery is executes Succesfully.
+ for(TInt index(0); index < uriCount ; index++)
+ {
+ CUPnPDescribeRequestParamSet* describeParamSet = CUPnPDescribeRequestParamSet::NewL (pnpFamily );
+ describeParamSet->SetUriL(iIconUriArray[index]);
+ RBuf uri16;
+ uri16.Create(iIconUriArray[index].Length());
+ uri16.Copy(iIconUriArray[index]);
+ _LIT(KScpdUriInfo,"SCPD Uri Submitted for Description Request is: %S \n");
+ INFO_PRINTF2(KScpdUriInfo, &uri16);
+ uri16.Close();
+ }
+ iControlPoint.Describe(pnpBundle );
+ CActiveScheduler::Start();
+ _LIT(KInfoLogFile1, "CTestUPnPManager::DescribeServiceL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ }
+
+void CTestUPnPManager::DescribeL()
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::DescribeL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ CUPnPObserver* upnpObserver = CUPnPObserver::NewL(this);
+ CleanupStack::PushL( upnpObserver );
+
+ RPnPParameterBundle pnpBundle;
+ pnpBundle.CreateL ();
+ CleanupClosePushL( pnpBundle );
+ pnpBundle.SetPnPObserver((MPnPObserver*)upnpObserver);
+
+ RParameterFamily pnpFamily = pnpBundle.CreateFamilyL (EUPnPDescribeRequestParamSet);
+ RBuf8 descriptionPathBuf;
+
+ TBool readIni = ETrue;
+ GetBoolFromConfig(GetCurrentSection(), KReadIni, readIni);
+ if(readIni)
+ {
+ // Get the Description path from .ini File
+ TPtrC descriptionPath;
+ GetStringFromConfig(GetCurrentSection(), KDescriptionPath, descriptionPath);
+ CUPnPDescribeRequestParamSet* describeParamSet = CUPnPDescribeRequestParamSet::NewL (pnpFamily );
+ descriptionPathBuf.Create(descriptionPath.Length());
+ descriptionPathBuf.Copy(descriptionPath);
+ describeParamSet->SetUriL(descriptionPathBuf);
+ descriptionPathBuf.Close();
+ iControlPoint.Describe( pnpBundle );
+ TBool SchedulerStatus = ETrue;
+ _LIT(KSchedulerStatus, "schedulerstart");
+ GetBoolFromConfig(GetCurrentSection(), KSchedulerStatus, SchedulerStatus);
+ if(SchedulerStatus)
+ {
+ CActiveScheduler::Start();
+ }
+ }
+ else
+ {
+ // Read the Description path from DevLoaction array
+ //Make sure that Before this Describe, Successful Discovery is happend.
+ TInt DevLocCount = iDeviceLocationArray.Count();
+ if ( DevLocCount==0 )
+ {
+ _LIT(KDescription,"Description Cannot be performed as NO Uri available to Describe\n");
+ INFO_PRINTF1(KDescription);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ //SetTestStepResult(EFail);
+ return;
+ }
+
+ //__ASSERT_DEBUG ( DevLocCount > 0, User::Panic (KDescribeTestPanicCategory,KErrNoDescriptionPath ) );
+
+ for(TInt iter(0); iter < DevLocCount ; iter++)
+ {
+ TBuf8<256> url;
+ TUriParser8 uri;
+ uri.Parse(iDeviceLocationArray[iter]);
+ const TDesC8& scheme = uri.Extract(EUriScheme);
+ _LIT8(KScheme, "http");
+ //Uri must be of scheme "http" only
+ if (scheme.CompareF(KScheme) == 0)
+ {
+ url.Copy(iDeviceLocationArray[iter]);
+ CUPnPDescribeRequestParamSet* describeParamSet = CUPnPDescribeRequestParamSet::NewL ( pnpFamily );
+ describeParamSet->SetUriL(url);
+ }
+ else
+ {
+ _LIT(KInavlidUri, "Describe Request for InvalidURi");
+ INFO_PRINTF1(KInavlidUri);
+ return;
+ }
+ }
+
+ iControlPoint.Describe(pnpBundle );
+ TBool SchedulerStatus = ETrue;
+ _LIT(KSchedulerStatus, "schedulerstart");
+ GetBoolFromConfig(GetCurrentSection(), KSchedulerStatus, SchedulerStatus);
+ if(SchedulerStatus)
+ {
+ CActiveScheduler::Start();
+ }
+ }
+ _LIT(KInfoLogFile1, "CTestUPnPManager::DescribeL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ CleanupStack::PopAndDestroy( &pnpBundle );
+ CleanupStack::PopAndDestroy( upnpObserver );
+ }
+
+void CTestUPnPManager::ResolveAllUrisL()
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::ResolveAllUrisL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TInt count = iDescriptionSuiteArray.Count();
+ //__ASSERT_DEBUG ( count > 0, User::Panic (KDescribeTestPanicCategory, KErrNoServiceUris ) );
+ if( count <=0 )
+ {
+ _LIT(KErrResolve, "No Description is exist to Resolve URIs");
+ ERR_PRINTF1(KErrResolve);
+ return;
+ }
+ //Fill the all types of Uris for each base Uri
+ for (TInt index(0); index < count ; index++ )
+ {
+ GetServiceUrlsListL(index);
+ ResolveScpdUrisL(index);
+ ResolveEventUrisL(index);
+ ResolveControlUrisL(index);
+ }
+ }
+
+void CTestUPnPManager::GetServiceUrlsListL(TInt aIndex)
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::GetServiceUrlsListL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ CUPnPDeviceDescription* rootDeviceDescription = NULL;
+ //Release the content of StringPool if any
+ if(iStringPoolMgr)
+ iStringPoolMgr->Release();
+ DeleteSeriveUrlsList(aIndex);
+
+ iStringPoolMgr = CStringPoolManager::NewL();
+ //Store the Parsed node info
+ iStringPool = iStringPoolMgr->StringPool();
+ _LIT(KInfoLogFile4, "Creating Stringpool and its manager.... \n");
+ INFO_PRINTF1(KInfoLogFile4);
+
+ //Parse the device description
+ CUPnPDescriptionParser* app = CUPnPDescriptionParser::NewL( iStringPool, CUPnPDescriptionParser::EDevice);
+ _LIT(KInfoLogFile2, "CTestUPnPManager::CUpnpDeviceXmlParser::NewL().... \n");
+ INFO_PRINTF1(KInfoLogFile2);
+ TRAPD(error,(rootDeviceDescription = static_cast(app->ParseDescriptionBufL(iDescriptionSuiteArray[aIndex].iDescription))));
+ if (error != KErrNone)
+ {
+ _LIT(KErrLogFile1, "CTestUPnPManager::GetServiceUrlsListL() is Terminating.... And Error is %d \n");
+ ERR_PRINTF2(KErrLogFile1, error);
+ return;
+ }
+ _LIT(KInfoLogFile3, "rootDeviceDescription.... \n");
+ INFO_PRINTF1(KInfoLogFile3);
+
+
+
+ delete app;
+ app = NULL;
+ _LIT(KInfoLogFile5, "Deleting CUpnpDeviceXmlParser().... \n");
+ INFO_PRINTF1(KInfoLogFile5);
+
+ //Retrieve the Tag for Base
+ RString string = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EUrlBase,iStringPoolMgr->GetUPnPTable());
+ //Get the node info for the Base i.e., value between the start and end Base tags
+ //If BaseUri exist in Description replace already existing BaseUri
+ if(rootDeviceDescription->Property(string).Compare(KNullDesC8)>0)
+ {
+ //Delete already stored Base uri
+ iDescriptionSuiteArray[aIndex].iBaseUrl.Close();
+ iDescriptionSuiteArray[aIndex].iBaseUrl.Create(rootDeviceDescription->Property(string).Length());
+ iDescriptionSuiteArray[aIndex].iBaseUrl.Copy(rootDeviceDescription->Property(string));
+ }
+
+ //Catch hold of first level of Device
+ CUPnPDevice* device = rootDeviceDescription->DeviceObject();
+
+ TInt count =device->CountOfEmbeddedDeviceInfoTable();
+ if(count>0)
+ {
+ for(TInt i=0;iAtEmbeddedDeviceInfoTable(i));
+ }
+ }
+ GetServiceValuesL(aIndex, device);
+
+ GetIconUrlsL( aIndex, device);
+
+ _LIT(KInfoLogFile6, "Finished GetServiceValuesL.... \n");
+ INFO_PRINTF1(KInfoLogFile6);
+ delete rootDeviceDescription;
+ rootDeviceDescription = NULL;
+ _LIT(KInfoLogFile1, "CTestUPnPManager::GetServiceUrlsListL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+void CTestUPnPManager::GetIconUrlsL ( TInt aBaseDescIdx, CUPnPDevice* aRootDevice )
+ {
+ RString strF = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EUrl,iStringPoolMgr->GetUPnPTable());
+
+ for ( TInt i = 0; i < aRootDevice->CountOfIconInfoTable (); i++ )
+ {
+ CUPnPIconInfo* iconInfo = aRootDevice->AtIconInfoTable(i);
+ ResolveIconUrlL ( aBaseDescIdx, iconInfo->Property(strF) );
+ }
+ for ( TInt i = 0; i < aRootDevice->CountOfEmbeddedDeviceInfoTable(); i++ )
+ {
+ GetIconUrlsL ( aBaseDescIdx, aRootDevice->AtEmbeddedDeviceInfoTable(i) );
+ }
+ }
+
+void CTestUPnPManager::DeleteSeriveUrlsList(TInt aIndex)
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::DeleteSeriveUrlsList().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ for(TInt i=0;iCountOfEmbeddedDeviceInfoTable() > 0)
+ {
+ for(TInt i=0;iCountOfEmbeddedDeviceInfoTable();i++)
+ {
+ GetEmbeddedDeviceServicesL(aIndex, aDevice->AtEmbeddedDeviceInfoTable(i));
+ GetServiceValuesL(aIndex, aDevice);
+ }
+ }
+ else
+ {
+ GetServiceValuesL(aIndex, aDevice);
+ }
+ }
+
+
+void CTestUPnPManager::AppendDeviceLocationL(TDesC8& aDevLocPointer)
+ {
+ User::LeaveIfError( iDeviceLocationArray.Append(aDevLocPointer) );
+ }
+
+void CTestUPnPManager::AppendScpdUriL(RBuf8& aScpdUri)
+ {
+ User::LeaveIfError( iScpdUriArray.Append(aScpdUri) );
+ }
+
+void CTestUPnPManager::AppendEventUriL(RBuf8& aEventUri)
+ {
+ User::LeaveIfError( iEventUriArray.Append(aEventUri) );
+ }
+
+void CTestUPnPManager::AppendControlUriL(RBuf8& aControlUri)
+ {
+ User::LeaveIfError( iControlUriArray.Append(aControlUri) );
+ }
+
+void CTestUPnPManager::AppendDescriptionL(RBuf8& aBaseUri,RBuf8& aDescription)
+ {
+ TDescriptionSuite buf;
+ buf.iDescription.CreateL(aDescription);
+ buf.iBaseUrl.CreateL(aBaseUri);
+ iDescriptionSuiteArray.Append(buf);
+ }
+
+void CTestUPnPManager::GetServiceValuesL(TInt aIndex, CUPnPDevice* aDevice)
+ {
+ _LIT(KInfoLogFile, "CTestUPnPManager::GetServiceValuesL().... \n");
+ INFO_PRINTF1(KInfoLogFile);
+
+ TUint count;
+ const CUPnPServiceInfo* servInfo = NULL;
+ TServiceUrl serviceurl;
+ count = aDevice->CountOfServiceInfoTable();
+ if(count > 0)
+ {
+ for(TInt i = 0; i< aDevice->CountOfServiceInfoTable(); i++)
+ {
+ servInfo = aDevice->AtServiceInfoTable(i);
+
+ RString string = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EServiceType, iStringPoolMgr->GetUPnPTable());
+ serviceurl.serviceType.Create(servInfo->Property(string).Length());
+ serviceurl.serviceType.Copy(servInfo->Property(string));
+
+ string = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EScpdUrl, iStringPoolMgr->GetUPnPTable());
+ serviceurl.scpdUrl.Create(servInfo->Property(string).Length());
+ serviceurl.scpdUrl.Copy(servInfo->Property(string));
+
+ string = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EContorlUrl, iStringPoolMgr->GetUPnPTable());
+ serviceurl.controlUrl.Create(servInfo->Property(string).Length());
+ serviceurl.controlUrl.Copy(servInfo->Property(string));
+
+ string = iStringPool.String(UPNPDESCRIPTIONXMLTAGS::EEventSubUrl, iStringPoolMgr->GetUPnPTable());
+ serviceurl.eventSubUrl.Create(servInfo->Property(string).Length());
+ serviceurl.eventSubUrl.Copy(servInfo->Property(string));
+
+ iDescriptionSuiteArray[aIndex].iServiceUrls.AppendL(serviceurl);
+ }
+ }
+ _LIT(KInfoLogFile1, "CTestUPnPManager::GetServiceValuesL() End.... \n");
+ INFO_PRINTF1(KInfoLogFile1);
+ }
+
+
+CUPnPTimer::CUPnPTimer(CTestUPnPManager* aManager)
+: CActive(EPriorityHigh),iManager(aManager)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+
+CUPnPTimer::~CUPnPTimer()
+ {
+ Cancel();
+ }
+
+
+CUPnPTimer* CUPnPTimer::NewL(CTestUPnPManager* aManager)
+ {
+ CUPnPTimer* self = new (ELeave) CUPnPTimer(aManager);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+void CUPnPTimer::ConstructL()
+ {
+ }
+
+
+void CUPnPTimer::IssueRequestL(TTimeIntervalMicroSeconds32 anInterval)
+ {
+ iTimer.CreateLocal();
+ iTimer.After(iStatus, anInterval);
+ SetActive();
+ _LIT(KInfoLogFile, "CUPnPTimer::IssueRequestL() End.... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+ }
+
+
+void CUPnPTimer::RunL()
+ {
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "CUPnPTimer::RunL() End.... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+
+ }
+
+void CUPnPTimer::DoCancel()
+ {
+ iTimer.Cancel();
+ }
+
+CAction* CAction::NewL(CTestUPnPManager* aManager)
+ {
+ CAction* self = new (ELeave) CAction(aManager);
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+
+ }
+
+CAction::CAction(CTestUPnPManager* aManager)
+: CActive(CActive::EPriorityStandard),iManager(aManager)
+ {
+
+ }
+
+CAction::~CAction()
+ {
+ Cancel();
+ iFile.Close ( );
+ iFs.Close ( );
+ }
+
+void CAction::ConstructL()
+ {
+ _LIT(KInfoLogFile, "CAction::ConstructL() .... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+ CActiveScheduler::Add(this);
+ _LIT(KPath, "c:\\upnp\\testupnp\\client\\testdata\\");
+ _LIT(KFile, "c:\\upnp\\testupnp\\client\\testdata\\actionresponse.xml");
+ User::LeaveIfError ( iFs.Connect ( ) );
+ TInt err = iFile.Open ( iFs, KFile, EFileWrite );
+ if(err == KErrNotFound)
+ {
+ err = iFile.Create(iFs,KFile,EFileWrite);
+ }
+ else if(err == KErrPathNotFound)
+ {
+ err= iFs.MkDirAll(KPath);
+ if(err==KErrNone || err== KErrAlreadyExists)
+ {
+ iFile.Create(iFs,KFile,EFileWrite);
+ }
+ }
+ else
+ {
+ User::LeaveIfError(err);
+ }
+ }
+
+void CAction::RunL()
+ {
+ switch(iActionState)
+ {
+ case ESendData:
+ iActionState = EReceiveData;
+ iControlChannel.Recv ( iCtrlMsg, iStatus );
+ SetActive();
+ _LIT(KInfoLogFile, "CAction::RunL Send Data.... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+ break;
+ case EReceiveData:
+ TInt err = iFile.Write(iCtrlMsg.MessageDes ());
+ if ( !iCtrlMsg.IsLast () )
+ {
+ iCtrlMsg.ClearFlags();
+ iControlChannel.Recv ( iCtrlMsg, iStatus );
+ SetActive();
+ _LIT(KInfoLogFile, "CAction::RunL Receive Data... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+ }
+ else
+ {
+ iControlChannel.Close( );
+ CActiveScheduler::Stop();
+ _LIT(KInfoLogFile, "CAction::RunL End.... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile);
+ }
+ break;
+ }
+ }
+
+void CAction::DoCancel()
+ {
+ }
+
+void CAction::InitiateActionControlL(TDesC8& aUri,RPnPServiceDiscovery& aControlPoint)
+ {
+ RFs fs;
+ RFile file;
+ TInt err;
+ RBuf8 buf;
+ _LIT(KInfoLogFile2, "InitiateActionControlL .... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile2);
+
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ err = file.Open(fs,_L("z:\\upnp\\testupnp\\client\\testdata\\action.xml"),EFileRead);
+ if (err != KErrNone)
+ {
+ User::LeaveIfError(err);
+ }
+ CleanupClosePushL(file);
+ TInt fileSize = 0;
+ file.Size(fileSize);
+ buf.Create(fileSize);
+ err = file.Read(buf, fileSize);
+ err= -1;
+ err = aControlPoint.InitiateControl ( iControlChannel, aUri );
+ _LIT(KInfoLogFile, "InitiateControl() on Control Point Done with %d.... \n");
+ iManager->INFO_PRINTF2(KInfoLogFile,err);
+ iCtrlMsg.SetMessageDes ( buf );
+ iCtrlMsg.SetLast ();
+ TInt newLen = buf.Length();
+ iCtrlMsg.SetMaxLength (newLen);
+ iControlChannel.Send ( iCtrlMsg, iStatus );
+ SetActive();
+ CActiveScheduler::Start();
+ _LIT(KInfoLogFile1, "InitiateActionControlL End.... \n");
+ iManager->INFO_PRINTF1(KInfoLogFile1);
+ CleanupStack::PopAndDestroy(2 );
+ }
+