// Copyright (c) 2006-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:

// Name          : CSdpMediaAttributeStrategy.cpp

// Part of       : SIP Client Resolver

// Version       : 1.0

//

#include "CSdpMediaAttributeStrategy.h"

#include "MSipClients.h"

#include "MSipClient.h"

#include "sdpdocument.h"

#include "sdpmediafield.h"

#include "sdpattributefield.h"

#include "sdpcodecstringconstants.h"

#include "sdpcodecstringpool.h"

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::NewLC

// ----------------------------------------------------------------------------

//

CSdpMediaAttributeStrategy* CSdpMediaAttributeStrategy::NewLC(

    const MSipClients& aSipClients)

	{

	CSdpMediaAttributeStrategy* self = 

		new(ELeave)CSdpMediaAttributeStrategy(aSipClients);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::CSdpMediaAttributeStrategy

// ----------------------------------------------------------------------------

//

CSdpMediaAttributeStrategy::CSdpMediaAttributeStrategy(

    const MSipClients& aSipClients) 

 : CSdpStrategyBase(aSipClients)

	{

	}

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::ConstructL

// ----------------------------------------------------------------------------

//

void CSdpMediaAttributeStrategy::ConstructL()

	{

	CSdpStrategyBase::ConstructL();

	}

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::~CSdpMediaAttributeStrategy

// ----------------------------------------------------------------------------

//

CSdpMediaAttributeStrategy::~CSdpMediaAttributeStrategy ()

	{

	}

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::ApplyL

// ----------------------------------------------------------------------------

//	

CSIPResponse* CSdpMediaAttributeStrategy::ApplyL(

    CSdpDocument& aDocument, 

    RArray<TUid>& aUids)

    {	

	RArray<TUid> uids;

	CleanupClosePushL(uids);

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

        {

        uids.AppendL(aUids[i]);

        }

	for (TInt i=uids.Count()-1; i>=0; i--)

		{

		MSipClient* client = iSipClients.GetByUID(uids[i]);

		if (client)

			{

        	if (!Match(aDocument,*client))

        	    {

			    uids.Remove(i);

        	    }           

			}		

		}

	if (uids.Count() > 0)

	    {

	    aUids.Reset();

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

            {

            aUids.AppendL(uids[i]);

            }	    

	    }

    CleanupStack::PopAndDestroy(&uids);

    return NULL;   

    }

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::Match

// ----------------------------------------------------------------------------

//

TBool CSdpMediaAttributeStrategy::Match(

    CSdpDocument& aDocument,

    MSipClient& aClient)

    {    

	RPointerArray<CSdpMediaField>& clientMedias = 

	    aClient.SdpDocument().MediaFields();

	RPointerArray<CSdpMediaField>& receivedMedias = 

	    aDocument.MediaFields();	

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

	    {

	    CSdpMediaField* receivedMedia = receivedMedias[i];

	    for (TInt j=0; j < clientMedias.Count(); j++)

            {

            CSdpMediaField* clientMedia = clientMedias[j];

            if (HasMatchingAttribute(*receivedMedia,*clientMedia))

                {

                return ETrue;

                }

	        }

	    }

	return EFalse;

	}

// ----------------------------------------------------------------------------

// CSdpMediaAttributeStrategy::HasMatchingAttribute

// ----------------------------------------------------------------------------

//    

TBool CSdpMediaAttributeStrategy::HasMatchingAttribute(

    CSdpMediaField& aReceivedMedia,

    CSdpMediaField& aClientMedia)

    {

    if (aReceivedMedia.Media() != aClientMedia.Media())

        {

        return EFalse;

        }

    const RPointerArray<CSdpAttributeField>& clientAttributes = 

	    aClientMedia.AttributeFields();	

    const RPointerArray<CSdpAttributeField>& receivedAttributes = 

	    aReceivedMedia.AttributeFields();	

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

	    {

    	for (TInt j=0; j < receivedAttributes.Count(); j++)

    	    {

    	    if (*clientAttributes[i] == *receivedAttributes[j])

    	        {

    	        return ETrue;

    	        }

    	    }

	    }    

    return EFalse;

    }