// Copyright (c) 2005-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          : CSdpMLineStrategyBase.cpp

// Part of       : SIP Client Resolver

// Version       : 1.0

//

#include "CSdpMLineStrategyBase.h"

#include "MSipClients.h"

#include "MSipClient.h"

#include "sipresponse.h"

#include "sdpdocument.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

const TUint K488ResponseCode = 488;

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

// CSdpMLineStrategyBase::CSdpMLineStrategyBase

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

//

CSdpMLineStrategyBase::CSdpMLineStrategyBase(const MSipClients& aSipClients)

: CSdpStrategyBase(aSipClients)

	{

	}

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

// CSdpMLineStrategyBase::~CSdpMLineStrategyBase

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

//

CSdpMLineStrategyBase::~CSdpMLineStrategyBase()

	{	

	}

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

// CSdpMLineStrategyBase::ApplyL

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

//

CSIPResponse* CSdpMLineStrategyBase::ApplyL(

    CSdpDocument& aDocument, 

    RArray<TUid>& aUids)

	{

	CSIPResponse* response = MediaLineExistL(aDocument);

	if (!response && IsApplicable(aDocument))

	    {

	    FindApplicationL(aDocument,aUids);

	    if(aUids.Count() == 0)

		    {

			response = CSIPResponse::NewL(

			    K488ResponseCode,

			    SIPStrings::StringF(SipStrConsts::EPhraseNotAcceptableHere));

		    }

	    }

	return response;

	}

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

// CSdpMLineStrategyBase::FindApplicationL

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

//

void CSdpMLineStrategyBase::FindApplicationL(CSdpDocument& aDocument,

                                             RArray<TUid>& aUids)

    {

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

		{

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

		if (!client || !MatchL(aDocument,*client))

			{

			aUids.Remove(i);

			i--;

			}		

		}

    }

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

// CSdpMLineStrategyBase::MediaLineExist

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

//

CSIPResponse* CSdpMLineStrategyBase::MediaLineExistL(CSdpDocument& aDocument)

 	{

   	if(aDocument.MediaFields().Count() == 0)

        {

        return CSIPResponse::NewL(K488ResponseCode,

            SIPStrings::StringF(SipStrConsts::EPhraseNotAcceptableHere));

        }

    return NULL;

    }

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

// CSdpMLineStrategyBase::MatchL

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

//

TBool CSdpMLineStrategyBase::MatchL(CSdpDocument& aDocument,

                                    MSipClient& aClient)

    {

	const RPointerArray<CSdpMediaField>& clientMedias = 

	    aClient.SdpDocument().MediaFields();

	const RPointerArray<CSdpMediaField>& receivedMedias = 

	    aDocument.MediaFields();	

	// All the media fields in received request must be supported 

	// by the client. If not the client is removed from the list of clients,

	// that are capable of handling the request.  

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

	    {

	    CSdpMediaField* receivedMedia = receivedMedias[i];

	    if (IsApplicable(*receivedMedia))

	        {

	        TBool mediaFound = EFalse;

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

	            {

	            if (FieldsMatchL(*receivedMedia,*(clientMedias[j])))

	                {

	                mediaFound = ETrue;

	                }

	            }

	        if (!mediaFound)

	            {

	            return EFalse;

	            }

	        }

	    }

	return ETrue;

	}

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

// CSdpMLineStrategyBase::IsApplicable

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

//	

TBool CSdpMLineStrategyBase::IsApplicable(CSdpDocument& aDocument)

    {

 	RPointerArray<CSdpMediaField>& mediaFields = aDocument.MediaFields();

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

	    {

	    if (IsApplicable(*mediaFields[i]))

	        {

	        return ETrue;

	        }

	    }

    return EFalse;

    }

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

// CSdpMLineStrategyBase::IsApplicable

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

//	

TBool CSdpMLineStrategyBase::IsApplicable(CSdpMediaField& /*aMediaField*/)

    {

    // default implementation

    return ETrue;

    }