servicediscoveryandcontrol/pnp/test/upnp/Server/ControlPoint/src/upnpctrlscpr.cpp
// 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:
// @file
// @internalComponent
//
//
#include <comms-infras/ss_msgintercept.h>
#include "upnp_cf_msgs.h"
#include "upnpsubconnevents.h"
#include "upnpctrlscpractivities.h"
#include "upnpuuid.h"
#include "upnplog.h"
#include "upnpcpr.h"
__FLOG_STMT(_LIT8(KComponent,"UPnPCtrlScpr");)
using namespace ESock;
CUPnPControlSubConnectionProvider* CUPnPControlSubConnectionProvider::NewL ( CSubConnectionProviderFactoryBase& aFactory )
{
CUPnPControlSubConnectionProvider* provider = new (ELeave) CUPnPControlSubConnectionProvider ( aFactory, UPnPControlSCprActivities::activityMap::Self() );
CleanupStack::PushL ( provider );
provider->ConstructL ( );
CleanupStack::Pop ( provider );
return provider;
}
CUPnPControlSubConnectionProvider::~CUPnPControlSubConnectionProvider ( )
{
LOG_NODE_DESTROY(KSubsysCtrlScpr, CUPnPControlSubConnectionProvider);
iResponseBundle.Close( );
iFlowInfo.Reset ( );
iSubscriptions.ResetAndDestroy();
iCallbackUrl.Close();
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("Destroyed CUPnPControlSubConnectionProvider")));
}
CUPnPControlSubConnectionProvider::CUPnPControlSubConnectionProvider ( CSubConnectionProviderFactoryBase& aFactory, const MeshMachine::TNodeActivityMap& aActivityMap )
: CUPnPSubConnectionProvider ( aFactory, aActivityMap ),
iTcpSrvFlowCreateRequested ( EFalse ), iResponseBlocked ( EFalse ), iUdpClientFlow ( TNodeId::NullId ( ) ), iUdpServerFlow ( TNodeId::NullId ( ) ), iTcpServerFlow ( TNodeId::NullId ( ) )
{
LOG_NODE_CREATE(KSubsysCtrlScpr, CUPnPControlSubConnectionProvider);
}
void CUPnPControlSubConnectionProvider::ConstructL ( )
{
CCoreSubConnectionProvider::ConstructL();
// make sure bundle constructs are initialised.
iResponseBundle.CreateL ();
iResponseBundle.Open ();
iRequestBundle.CreateL ();
iQueueBundle.CreateL ();
RParameterFamily discover = iQueueBundle.CreateFamilyL ( EUPnPDiscoverResponseParamSet );
RParameterFamily presenceNotify = iQueueBundle.CreateFamilyL ( EUPnPPresenceAnnouncementParamSet );
RParameterFamily absenceNotify = iQueueBundle.CreateFamilyL ( EUPnPAbsenceAnnouncementParamSet );
RParameterFamily describe = iQueueBundle.CreateFamilyL ( EUPnPDescribeResponseParamSet );
RParameterFamily subscribe = iQueueBundle.CreateFamilyL ( EUPnPSubscribeResponseParamSet );
RParameterFamily eventNotify = iQueueBundle.CreateFamilyL ( EUPnPNotifyEventParamSet );
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("Created CUPnPControlSubConnectionProvider")));
}
void CUPnPControlSubConnectionProvider::ReceivedL ( const TRuntimeCtxId& aSender, const TNodeId& aRecipient, TSignatureBase& aMessage )
{
ESOCK_DEBUG_MESSAGE_INTERCEPT ( aSender, aMessage, aRecipient );
TNodeContext<CUPnPControlSubConnectionProvider> ctx(*this, aMessage, aSender, aRecipient);
CCoreSubConnectionProvider::ReceivedL ( aSender, aRecipient, aMessage );
User::LeaveIfError ( ctx.iReturn );
}
void CUPnPControlSubConnectionProvider::HandlePassThroughMessage ( MeshMachine::TNodeContextBase& aContext )
{
AMMNodeBase::HandlePassThroughMessage (aContext);
if ( aContext.iMessage.MessageId ().MessageId () != Messages::KNullMessageId )
// message is not handled by any of the upnp activity, free the data passed by dataplane
{
if ( aContext.iMessage.MessageId ().MessageId () == TUpnpMessage::TCancelParamSet::EId )
{
TUpnpMessage::TCancelParamSet& msg = message_cast< TUpnpMessage::TCancelParamSet > ( aContext.iMessage );
CUPnPRequestParamSetBase* cancelParamSet = static_cast<CUPnPRequestParamSetBase*> ( msg.iParamSet );
STypeId metaType = cancelParamSet->GetTypeId( );
if ( metaType.iType == EUPnPCancelDescribeParamSet )
{
CleanupEventQueuedResponses ( cancelParamSet->Uri (), EUPnPDescribeResponseParamSet );
delete static_cast<CUPnPCancelDiscoverParamSet*> ( cancelParamSet );
}
}
}
// clear message id now
aContext.iMessage.ClearMessageId ( );
}
void CUPnPControlSubConnectionProvider::InitiateActivitiesL ( )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateActivitiesL")));
RParameterFamily paramFamily = iRequestBundle.GetFamilyAtIndex (0);
switch ( paramFamily.Id() )
{
case EUPnPClearParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateActivitiesL - TUPnPParamSetFamily::EUPnPClearParamSet")));
ClearResponseParamL ( );
}
break;
case EUPnPDiscoverRequestParamSet:
case EUPnPRegisterAnnouncementParamSet:
case EUPnPDescribeRequestParamSet:
case EUPnPSubscribeRequestParamSet:
case EUPnPCancelDiscoverParamSet:
case EUPnPCancelDescribeParamSet:
case EUPnPCancelSubscribeParamSet:
case EUPnPCancelRegisterNotifyParamSet:
{
InitiateRequestL ( paramFamily ) ;
}
break;
default:
break;
}
iRequestBundle.DeleteFamilyAtIndex (0);
}
void CUPnPControlSubConnectionProvider::ClearResponseParamL ( )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::ClearResponseParamL")));
iResponseBlocked = EFalse;
NotifySubConnectionIfResultsAvailable ();
}
void CUPnPControlSubConnectionProvider::NotifySubConnectionIfResultsAvailable ( )
{
if ( IsClosing ( ) )
{
return;
}
TUint32 familyType;
if ( CheckForResultsAvailability ( familyType ) )
{
TRAP_IGNORE ( NotifySubConnectionL ( familyType ) );
}
}
void CUPnPControlSubConnectionProvider::NotifySubConnectionL ( const TUint32 aFamilyId )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::NotifySubConnectionL")));
RParameterFamily respFamily = iResponseBundle.CreateFamilyL ( aFamilyId );
RParameterFamily queueFamily = iQueueBundle.FindFamily ( aFamilyId );
TInt count = queueFamily.CountParameterSets ( RParameterFamily::ERequested );
TInt pos;
for ( pos = 0; pos < count; pos++ )
{
XParameterSetBase* paramSet = queueFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested );
respFamily.AddParameterSetL ( paramSet, RParameterFamily::ERequested );
queueFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested);
}
// Cant help it out......tried to convince ESock team
pos = count - 1;
while ( pos >= 0 )
{
reinterpret_cast<RUPnPParameterFamily*>(&queueFamily)->DeleteParamSetL ( pos );
--pos;
}
CUPnPSubConnEvent* subConnEvent = CUPnPSubConnEvent::NewL ( );
TCleanupItem item ( &CUPnPSubConnEvent::CleanupSubConnEvent, subConnEvent );
CleanupStack::PushL ( item );
subConnEvent->SetFamily ( aFamilyId );
NotifyClientsL ( *subConnEvent );
CleanupStack::Pop ( ); // item
iResponseBlocked = ETrue;
}
TBool CUPnPControlSubConnectionProvider::CheckForResultsAvailability ( TUint32& aFamilyId )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::CheckForResultsAvailability")));
TInt familyCount = iQueueBundle.CountParameterFamilies ();
for( TInt index = 0; index < familyCount; index++ )
{
RParameterFamily paramFamily = iQueueBundle.GetFamilyAtIndex ( index );
if( paramFamily.CountParameterSets ( RParameterFamily::ERequested ) > 0)
{
//There are pending responses available. return the family id.
aFamilyId = paramFamily.Id();
return ETrue;
}
}
return EFalse;
}
CUPnPControlConnectionProvider& CUPnPControlSubConnectionProvider::ConnectionProvider ( )
{
CUPnPConnectionProvider& cprBase = BaseConnectionProvider();
return static_cast<CUPnPControlConnectionProvider&>(cprBase);
}
void CUPnPControlSubConnectionProvider::InitiateRequestL ( RParameterFamily& aReqFamily )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL")));
TInt familyId = aReqFamily.Id();
TUint count = aReqFamily.CountParameterSets ( RParameterFamily::ERequested );
switch(familyId)
{
case EUPnPDiscoverRequestParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDiscoverRequestParamSet")));
// while ( count != 0 )
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDiscoverRequestParamSet - Posting message TUpnpMessage::TSearchRequest")));
//post the message to start the activity and takes ownership of parameter set
CUPnPDiscoverRequestParamSet* paramSet = static_cast<CUPnPDiscoverRequestParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TSearchRequest ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPCancelDiscoverParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelDiscoverParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelDiscoverParamSet - Posting message TUpnpMessage::TDataClientStop")));
//post the message to start the activity and takes ownership of parameter set
CUPnPCancelDiscoverParamSet* paramSet = static_cast<CUPnPCancelDiscoverParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TCancelParamSet ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPRegisterAnnouncementParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPRegisterAnnouncementParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPRegisterAnnouncementParamSet - Posting message TUpnpMessage::TRegisterNotifyRequest")));
//post the message to start the activity and takes ownership of parameter set
CUPnPRegisterAnnouncementParamSet* paramSet = static_cast<CUPnPRegisterAnnouncementParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TRegisterNotifyRequest ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPCancelRegisterNotifyParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelRegisterNotifyParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelRegisterNotifyParamSet - Posting message TUpnpMessage::TDataClientStop")));
CUPnPCancelRegisterNotifyParamSet* paramSet = static_cast<CUPnPCancelRegisterNotifyParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
//post the message to start the activity and takes ownership of parameter set
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TCancelParamSet ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPDescribeRequestParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDescribeRequestParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPDescribeRequestParamSet - Posting message TUpnpMessage::TDescribeRequest")));
//post the message to start the activity and takes ownership of parameter set
CUPnPDescribeRequestParamSet* paramSet = static_cast<CUPnPDescribeRequestParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TDescribeRequest ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPCancelDescribeParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelDescribeParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelDescribeParamSet - Posting message TUpnpMessage::TDataClientStop")));
//post the message to start the activity and takes ownership of parameter set
CUPnPCancelDescribeParamSet* paramSet = static_cast<CUPnPCancelDescribeParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TCancelParamSet ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPSubscribeRequestParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPSubscribeRequestParamSet")));
GenerateCallbackUrlL ();
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPSubscribeRequestParamSet - Posting message TUpnpMessage::TSubscribeRequest")));
//post the message to start the activity and takes ownership of parameter set
CUPnPSubscribeRequestParamSet* paramSet = static_cast<CUPnPSubscribeRequestParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TSubscribeRequest ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
case EUPnPCancelSubscribeParamSet:
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelSubscribeRequestParamSet")));
for ( TInt pos = 0; pos < count; pos++ )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::InitiateRequestL - TUPnPParamSetFamily::EUPnPCancelSubscribeRequestParamSet - Posting message TUpnpMessage::TSubscribeRequest")));
//post the message to start the activity and takes ownership of parameter set
CUPnPCancelSubscribeParamSet* paramSet = static_cast<CUPnPCancelSubscribeParamSet*> (aReqFamily.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
RClientInterface::OpenPostMessageClose ( NodeId (), NodeId (), TUpnpMessage::TCancelParamSet ( paramSet ).CRef () );
aReqFamily.ClearParameterSetPointer( pos, RParameterFamily::ERequested );
}
break;
}
default:
break;
}
}
void CUPnPControlSubConnectionProvider::AddResponseParamSetL ( XParameterSetBase* aResponseSet, const TUint32 aFamilyId )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::AddResponseParamSetL")));
__ASSERT_DEBUG( aResponseSet != NULL, User::Invariant() );
if ( IsClosing ( ) )
{
delete aResponseSet;
return;
}
RParameterFamily queueFamily = iQueueBundle.FindFamily ( aFamilyId );
queueFamily.AddParameterSetL ( aResponseSet, RParameterFamily::ERequested );
if(!iResponseBlocked)
{
NotifySubConnectionL(aFamilyId);
}
}
void CUPnPControlSubConnectionProvider::GenerateCallbackUrlL ( )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GenerateCallbackUrlL")));
if ( iCallbackUrl.Length ( ) != 0 )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GenerateCallbackUrlL - Callback url already present")));
return;
}
RBuf8 uuid;
UpnpUuid::GenerateUuidL( uuid );
CleanupClosePushL( uuid );
#if !defined(__GCCXML__)
CConnectionProviderBase& cprBase = mnode_cast<CConnectionProviderBase>(ControlProvider()->RecipientId().Node());
#else
CConnectionProviderBase& cprBase =
reinterpret_cast<CConnectionProviderBase&>(ControlProvider()->RecipientId().Node());
#endif
CUPnPControlConnectionProvider& upnpCpr = static_cast<CUPnPControlConnectionProvider&>(cprBase);
const TDesC8& rootLoc = upnpCpr.RootDeviceLocation ();
iCallbackUrl.CreateL ( rootLoc.Length ( ) + uuid.Length ( ) );
iCallbackUrl.Copy ( rootLoc );
iCallbackUrl.Append ( uuid );
CleanupStack::PopAndDestroy( &uuid );
}
// UPnp Subscription Information Elements management API's
CSubscriptionInfo* CUPnPControlSubConnectionProvider::GetSubscriptionInfoByUrl( const TDesC8& aPublishUrl )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoByUrl")));
TUint count = iSubscriptions.Count ( );
for ( TInt index = 0; index < count; index++ )
{
if ( iSubscriptions[index]->iPublishUrl.CompareF ( aPublishUrl ) == 0 )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoByUrl - Found subscription info")));
return iSubscriptions[index];
}
}
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoByUrl - Subscription info not found")));
return NULL;
}
CSubscriptionInfo* CUPnPControlSubConnectionProvider::GetSubscriptionInfoBySid ( const TDesC8& aSid )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoBySid")));
TUint count = iSubscriptions.Count ( );
for ( TInt index = 0; index < count; index++ )
{
if ( iSubscriptions[index]->iSid.CompareF ( aSid ) == 0 )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoBySid - Found subscription info")));
return iSubscriptions[index];
}
}
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::GetSubscriptionInfoBySid - Subscription info not found")));
return NULL;
}
void CUPnPControlSubConnectionProvider::AddSubscriptionInfoL(CSubscriptionInfo* aSubscriptionInfo)
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::AddSubscriptionInfoL")));
iSubscriptions.Append ( aSubscriptionInfo );
}
void CUPnPControlSubConnectionProvider::RemoveSubscriptionInfo ( const TDesC8& aSid )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CUPnPControlSubConnectionProvider::RemoveSubscriptionInfo by Sid ")));
CSubscriptionInfo* info = GetSubscriptionInfoBySid ( aSid );
__ASSERT_DEBUG ( info != NULL, User::Invariant ( ) );
CleanupEventQueuedResponses ( info->iPublishUrl, EUPnPNotifyEventParamSet );
TInt pos = iSubscriptions.Find ( info );
iSubscriptions.Remove ( pos );
delete info;
}
void CUPnPControlSubConnectionProvider::CleanupEventQueuedResponses ( const TDesC8& aUrl, TUint aFamilyId )
{
RParameterFamily family = GetUPnPFamilyById ( aFamilyId );
// check if response is already available and delete it
TInt pos = family.CountParameterSets ( RParameterFamily::ERequested ) - 1;
while ( pos >= 0 )
{
CUPnPRequestParamSetBase* paramSet = static_cast<CUPnPRequestParamSetBase*> ( family.GetParameterSetAtIndex ( pos, RParameterFamily::ERequested ) );
if ( paramSet->Uri ().CompareF ( aUrl ) == 0 )
{
LOG(ESockLogExternal::Printf(KSubsysCtrlScpr, KComponent, _L8("CleanupEventQueuedResponses - Queued notification is deleted %d "), pos));
TRAP_IGNORE ( reinterpret_cast<RUPnPParameterFamily*>(&family)->DeleteParamSetL( pos ) );
}
--pos;
}
}
RParameterFamily CUPnPControlSubConnectionProvider::GetUPnPFamilyById ( TUint32 aFamilyId )
{
RParameterFamily family;
TUint fC = iQueueBundle.CountParameterFamilies ();
for ( TInt pos = 0; pos < fC; pos++ )
{
family = iQueueBundle.GetFamilyAtIndex ( pos );
if ( aFamilyId== family.Id() )
{
break;
}
}
return family;
}