// 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:

//

#include "cupnpsubscribe.h"

#include "upnpconstants.h"

#include "pnputils.h"

#include <e32const.h>

CUPnPSubscribe::CUPnPSubscribe(RSubConnection& aSubConnection , RHostResolver& aResolver):iSubConnection(aSubConnection)

	,iResolver ( aResolver )

	{

	}

CUPnPSubscribe* CUPnPSubscribe::NewL(RSubConnection& aSubConnection , RHostResolver& aResolver)

	{

	CUPnPSubscribe* subscribe=new ( ELeave ) CUPnPSubscribe(aSubConnection , aResolver);

	CleanupStack::PushL( subscribe );

	subscribe->ConstructL();

	CleanupStack::Pop();

	return subscribe;

	}

void CUPnPSubscribe::ConstructL()

	{

	iDeltaTimer=CDeltaTimer::NewL(EPriorityLow);

	}

CUPnPSubscribe:: ~CUPnPSubscribe()

	{

	iDeltaTimer->Cancel();	

	delete iDeltaTimer;

	delete iElementArray;

	iTimerMappedArray.ResetAndDestroy();

	iCallbackArray.ResetAndDestroy();

	iMappedUri=NULL;

	}

/* Sends a subscribe request to the service point.It resolves all the uris passed

   in the parameter bundle to ip addresses if they're passed as domain names and

   appends them to element array

   @param aServiceInfo The parameter bundle which contains the uris to be sent

   describe requests to

 */

void CUPnPSubscribe::SubmitRequestL(const RPnPParameterBundle& aServiceInfo)

	{

	TInt paramIndex=0;

	RParameterFamily family = const_cast<RPnPParameterBundle&>(aServiceInfo).FindFamily( EUPnPSubscribeRequestParamSet );

	// Iteration 1 : Mainly used for resubscribing request. All the entries

	// corresponding to the uri which've been subscribed for before and are

	// present in this parameter set are removed

	CUPnPSubscribeRequestParamSet* paramSet  = NULL;

	TUint count = family.CountParameterSets ( RParameterFamily::ERequested ) ;

	for ( paramIndex = count - 1; paramIndex >= 0; paramIndex-- )

		{

		paramSet = static_cast<CUPnPSubscribeRequestParamSet*> ( family.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );

		const TDesC8& uri = paramSet->Uri();

		__ASSERT_DEBUG( paramSet->Uri() != KNullDesC8, User::Panic( KUPnPInvalidUserInput, KUPnPErrInvalidInput ) );

		__ASSERT_DEBUG( paramSet->Duration() > 0, User::Panic( KUPnPInvalidUserInput, KUPnPErrInvalidInput ) );

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

			{

			if(iTimerMappedArray[i]->UriExists(uri))

				{

				CTimerMappedUri* timerUri = iTimerMappedArray[i];

				iDeltaTimer->Remove(timerUri->GetTimerEntry());

				iTimerMappedArray.Remove(i);

				delete timerUri;

				break;

				}

			}

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

			{

			if(uri.CompareF(iCallbackArray[i]->GetUri()) == NULL)

				{

				CCallbackArgument* callArgument = iCallbackArray[i];

				iCallbackArray.Remove(i);

				delete callArgument;

				break;

				}

			}

		if( iElementArray && iElementArray->MatchElement(uri))

			iElementArray->RemoveElement(uri);

		}

	// Initialize the iterator . The uris will be checked for duplication,resolved

	// and appended

	TInetAddr address;

	for ( paramIndex = count - 1; paramIndex >= 0; paramIndex-- )

		{

			paramSet = static_cast<CUPnPSubscribeRequestParamSet*> ( family.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested ) );

			const TDesC8& uri = paramSet->Uri();

		// Creates a new Element array if one is not already present and

		// appends the uri to it. If the uri is duplicate then the corresponding param

		// set is removed

		if(!iElementArray)

			{

			iElementArray = new CUPnPElementArray;

			User::LeaveIfNull(iElementArray);

			iElementArray->InsertElementL(aServiceInfo.PnPObserver(), uri);

			}

		else

			{

			if(!iElementArray->MatchElement(uri))

				{

				iElementArray->InsertElementL(aServiceInfo.PnPObserver(),uri);

				}

			else

				{

				reinterpret_cast<RUPnPParameterFamily*>(&family)->DeleteParamSetL(paramIndex);

				continue;

				}

			}

		CUPnPUtils::ResolveHostAddressL ( iResolver, paramSet->Uri(), address );

		paramSet->SetRemoteHost ( address );

		}

	/* Finally if all other processing is done successfully do the

	 * set params

	 */

	if ( family.CountParameterSets(RParameterFamily::ERequested)>=1)

		User::LeaveIfError(iSubConnection.SetParameters(aServiceInfo));

	}

/* On expiry of the CDeltaTimer associated with the requested uri

 * it removes the corresponding from the element array and notifies the client

 */

TInt CUPnPSubscribe::OnTimerExpiry(TAny* aPtr)

	{

	TInt error = KErrNone;

	CCallbackArgument* pointerData= static_cast<CCallbackArgument*> (aPtr);

	CUPnPSubscribe* thisObject= static_cast<CUPnPSubscribe*> (pointerData->GetThisPointer());

	CUPnPElementArray* thisElementArray=thisObject->ElementArrayHandle();

	RPointerArray<CTimerMappedUri>& timerArray=thisObject->GetTimerArray();

	RPointerArray<CCallbackArgument>& argArray = thisObject->GetArgumentArray();

	const TDesC8& uri = pointerData->GetUri();

	TInt index;

	for( index=0; index<timerArray.Count(); index++ )

		{

		if(timerArray[index]->UriExists(uri))

			{

			CTimerMappedUri* timerUri = timerArray[index];

			timerArray.Remove(index);

			delete timerUri;

			index = -1;

			break;

			}

		}

	__ASSERT_DEBUG( index == -1 ,User::Panic(KUPnPTimerUriNotFound,KUPnPErrTimerError) );

	for( index=0; index<argArray.Count(); index++ )

		{

		const TDesC8& testUri = argArray[index]->GetUri();

		if(uri.CompareF(argArray[index]->GetUri())==NULL)

			{

			argArray.Remove(index);

			break;

			}

		}

	MPnPObserver* observer = thisElementArray->MatchElement(uri);

	__ASSERT_DEBUG( observer , User::Invariant());

	// Removes the uri from the element Array 

	HBufC8* notifyUri = pointerData->GetUri().Alloc();

	__ASSERT_DEBUG( notifyUri , User::Invariant());

	// Deletes the CCallbackargument data

	delete pointerData;

	// Notifies the client that timer has expired

	TRAP(error,thisObject->MakeBundleAndNotifyL(observer, notifyUri));

	return KErrNone;

	}

/* Passes back the response bundle to the client. A response bundle

 will contain only one parameter set consequently with a single observer

 */

void CUPnPSubscribe::NotifyResultsL(TUint32 aFamilyId, RPnPParameterBundleBase& aBundle)

	{

	MPnPObserver* observer = NULL;

	User::LeaveIfNull(iElementArray);

	CUPnPSubscribeResponseParamSet* subscribeParamSet  = NULL;

	CUPnPNotifyEventParamSet* notifyParamSet  = NULL;	

	RParameterFamily family ;

	switch(aFamilyId)

		{

		case EUPnPSubscribeResponseParamSet:

			{

			// Response to subscription request

			family = aBundle.FindFamily(EUPnPSubscribeResponseParamSet);			

			__ASSERT_DEBUG(!family.IsNull (), User::Panic(KUPnPInvalidFamily,KUPnPErrInvalidFamily));	

			__ASSERT_DEBUG(family.CountParameterSets(RParameterFamily::ERequested) > 0, User::Panic(KUPnPNoParamSet,KUPnPErrNoParamSet));				

			TUint count = family.CountParameterSets ( RParameterFamily::ERequested ) ;

			for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )

				{

				 subscribeParamSet = static_cast<CUPnPSubscribeResponseParamSet*> (family.GetParameterSetAtIndex(paramIndex,RParameterFamily::ERequested));

				 switch(( subscribeParamSet->UPnPEvent() ).iStatus)

					{

					case TUPnPEvent::ESuccess:

						{

						/* Extract the uri and the expiry time which has been supplied by

						 * the server and create a deltatimer entry using them

						 */ 

						TInt subscribeExpiryTime = subscribeParamSet->GetTimerExpiry();

						const TDesC8& uri = subscribeParamSet->Uri();

						observer = iElementArray->MatchElement(uri);

						__ASSERT_DEBUG( observer != NULL, User::Panic(KUPnPResponseUriNotFound,KUPnPErrResponseUriNotFound));

						CreateTimerEntryL(uri,subscribeExpiryTime);

						}

					break;

					case TUPnPEvent::EFail:

						{

						const TDesC8& uri = subscribeParamSet->Uri();

						observer=iElementArray->MatchElement(uri);

						__ASSERT_DEBUG( observer != NULL, User::Panic(KUPnPResponseUriNotFound,KUPnPErrResponseUriNotFound));

						iElementArray->RemoveElement(uri);

						}

					break;

					default:

						__ASSERT_DEBUG(0, User::Panic(KUPnPInvalidFamily,KUPnPErrInvalidFamily));	

					}

				}

			}

		break;

		case EUPnPNotifyEventParamSet:

			{

			// Eventing parameter set

			family = aBundle.FindFamily( EUPnPNotifyEventParamSet );

			TUint count = family.CountParameterSets ( RParameterFamily::ERequested ) ;			

			notifyParamSet = static_cast<CUPnPNotifyEventParamSet*> ( family.GetParameterSetAtIndex ( count - 1, RParameterFamily::ERequested ) );	

			observer = iElementArray->MatchElement(notifyParamSet->Uri());

			__ASSERT_DEBUG( observer != NULL, User::Panic(KUPnPResponseUriNotFound,KUPnPErrResponseUriNotFound));

			}

			break;

		default:

			__ASSERT_DEBUG(0, User::Panic(KUPnPInvalidFamily,KUPnPErrInvalidFamily));	

		}

	observer->OnPnPEventL(aBundle) ;

	}

/* Makes a bundle on expiry of the timer and sends it the client application

 * saying "Subscription has timed out"

 */

void CUPnPSubscribe::MakeBundleAndNotifyL(MPnPObserver* aObserver, HBufC8* aUri)

	{

	RPnPParameterBundleBase pnpBundle ;

	pnpBundle.Open();		

	CleanupClosePushL( pnpBundle );

	RParameterFamily family = pnpBundle.CreateFamilyL(EUPnPSubscribeResponseParamSet);

	// Create a new Param set

    CUPnPSubscribeResponseParamSet* subscribeParamSet = CUPnPSubscribeResponseParamSet::NewL(family );

    // Set the values for the event

    TUPnPEvent event;

    event.iStatus=TUPnPEvent::ESubscriptionTimeout;

    event.iErrorCode = KErrTimedOut;

   // Set the values in the parameter set

    subscribeParamSet->SetUPnPEvent(event);

    subscribeParamSet->SetUriL ( *aUri );

    subscribeParamSet->SetTimerExpiry(NULL);

    CleanupStack::Pop( &pnpBundle);

    delete aUri;

    aObserver->OnPnPEventL( pnpBundle ) ;

	}

/* CancelDescribe is used to send cancel subscribe requests to the network

 @param aServiceInfo The bundle which contains the list of uris whose describe

 		request should be cancelled

 */

void CUPnPSubscribe::CancelSubscribeL( const RPnPParameterBundle& aServiceInfo )

	{

	User::LeaveIfNull(iElementArray);	

	RParameterFamily family = const_cast<RPnPParameterBundle&>(aServiceInfo).FindFamily( EUPnPCancelSubscribeParamSet );

	CUPnPCancelSubscribeParamSet* paramSet = NULL;

	TUint count = family.CountParameterSets ( RParameterFamily::ERequested ) ;

	for ( TInt paramIndex = count - 1; paramIndex >= 0; paramIndex-- )

	{

		paramSet = static_cast<CUPnPCancelSubscribeParamSet*> ( family.GetParameterSetAtIndex ( paramIndex, RParameterFamily::ERequested) );

		//Extract the uri

		const TDesC8& uri = paramSet->Uri();

		__ASSERT_DEBUG( paramSet->Uri() != KNullDesC8, User::Panic( KUPnPInvalidUserInput, KUPnPErrInvalidInput ) );

		// Removes the uri entry from the array if exists

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

			{

			if(iTimerMappedArray[i]->UriExists(uri) )

				{

				CTimerMappedUri* timerUri = iTimerMappedArray[i];

				iDeltaTimer->Remove(timerUri->GetTimerEntry());

				iTimerMappedArray.Remove(i);

				delete timerUri;

				break;

				}

			}

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

			{

			if(uri.CompareF(iCallbackArray[i]->GetUri()) == NULL)

				{

				CCallbackArgument* callArgument = iCallbackArray[i];

				iCallbackArray.Remove(i);

				delete callArgument;

				break;

				}

			}

		// Remove the entry from element array

		MPnPObserver* observer = iElementArray->MatchElement( uri );

		if ( !observer )

			{		

			reinterpret_cast<RUPnPParameterFamily*>(&family)->DeleteParamSetL ( paramIndex );

			continue;

			}

		iElementArray->RemoveElement( uri );

		}

	if ( family.CountParameterSets(RParameterFamily::ERequested) >= 1)

		User::LeaveIfError(iSubConnection.SetParameters( aServiceInfo ));

	}

/* The timer delay is adjusted to 90% of the subscription time.Also it is adjusted

   for microseconds and IPC lag

 */

TInt CUPnPSubscribe::AdjustedDelay( TInt aTime )

	{

	TUint64 divisor = 10;

	TUint64 temp; // just a placeholder

	TUint64 q = Math::UDivMod64(aTime,divisor,temp);

	temp = q*(divisor-1);

	aTime = static_cast<TInt>(temp);

	const TInt KIntTime = 1000000 ;

	const TInt KInternalIPCLag = 1;

	aTime = ( aTime + KInternalIPCLag ) * KIntTime ;

	return aTime;

	}

/* CreateTimerEntry : creates the deltatimer entry and queues it up

 */

void CUPnPSubscribe::CreateTimerEntryL(const TDesC8& aUri ,TInt aExpiryTime)

	{

	CCallbackArgument* callArgument = CCallbackArgument::NewL(this,aUri);

	CleanupStack::PushL(callArgument);

	iCallbackArray.AppendL(callArgument);

	CleanupStack::Pop();

	TCallBack callBack(OnTimerExpiry,callArgument);

	iTimerEntry = new(ELeave) TDeltaTimerEntry( callBack );

	iMappedUri = CTimerMappedUri::NewL(aUri, iTimerEntry,aExpiryTime);

	iTimerMappedArray.AppendL(iMappedUri);

	// The time is set to 90% of the given time to allow the user

	// to resubscribe before the expiry time

	TInt time = AdjustedDelay(aExpiryTime);

	TTimeIntervalMicroSeconds32 delay(time);

	iDeltaTimer->Queue(delay,*iTimerEntry);

	}