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

//

#include <ecom/ecom.h>

#include <ecom/ecomerrorcodes.h>

#include <ecom/ecomresolverparams.h>

#include <ecom/implementationinformation.h>

#include <ecom/publicregistry.h>

#include <mdf/codecapiresolverdata.h>

#include <mdf/codecapiresolverutils.h>

#include <mdf/codecapivideoresolverutils.h>

#include <mdf/codecapiuids.hrh>

#include "codecapiresolver.h"

/**

Constructs a CCodecApiResolver object.

@param  aRegistry

		A reference to the instantiated registry information 

@return An instance of the class or NULL.

*/

CCodecApiResolver* CCodecApiResolver::NewL (MPublicRegistry& aRegistry)

	{

	return new(ELeave) CCodecApiResolver (aRegistry);

	}

/**

Class destructor.

*/

CCodecApiResolver::~CCodecApiResolver()

	{

	}

/**

Class constructor.

*/

CCodecApiResolver::CCodecApiResolver (MPublicRegistry& aRegistry) :

	CResolver (aRegistry)

	{

	}

/**

Requests the resolver to identify the most appropriate interface implementation.

@param  aInterfaceUid

		The interface for which an implementation is requested.

@param  aAdditionalParameters

	    The parameters which must match for an implementation to be suitable. 

@return The unique id of the implementation which satisfies the specified parameters. 

 		KNullUid if not implementation is found.

*/ 

TUid CCodecApiResolver::IdentifyImplementationL(TUid /*aInterfaceUid*/,

	const TEComResolverParams& /*aAdditionalParameters*/) const

	{

	return KNullUid;

	}

/**

Lists all the implementations which satisfy the specified interface definition and the 

resolve parameters supplied.

@param  aInterfaceUid

		The interface for which an implementation is requested.

@param  aAdditionalParameters	  	

		The parameters which must match for an implementation to be suitable.

@return Pointer to an array of suitable implementations. Ownership of this array is passed

	    to the calling function. 

*/

RImplInfoArray* CCodecApiResolver::ListAllL(TUid aInterfaceUid,

	const TEComResolverParams& aAdditionalParameters) const

	{

	RImplInfoArray* retList = new (ELeave) RImplInfoArray;

	// coverity[double_push]

	CleanupStack::PushL(retList);

	CleanupClosePushL(*retList);

	CCodecApiResolverData* customMatch = CCodecApiResolverData::NewLC(aAdditionalParameters.DataType());

	TCodecApiResolverMatchType matchType = customMatch->MatchType();

	TUid implementationTypeUid 			 = customMatch->ImplementationType();

	// create a list with all 

	RImplInfoArray& fullList = iRegistry.ListImplementationsL(aInterfaceUid);

	const TInt count = fullList.Count();

	for(TInt index = 0; index < count; index++)

		{

		TBool matchFound = EFalse;

		const CImplementationInformation& impData = *(fullList[index]);

		CCodecApiOpaqueData* parse = NULL;

		const TDesC8* opaqueData = &impData.OpaqueData();

		// if opaque data is empty, move to the next element in the list

		if (opaqueData->Length() == 0)

			{

			continue;

			}

		// create an instance of the class which holds the opaque data	

		TInt error = KErrNotFound;

		if (implementationTypeUid == TUid::Uid(KUidAudioCodec)) 

			{

			TRAP(error, parse = CCodecApiOpaqueData::NewL(impData.OpaqueData()));	

			}

		else

			{

			if ((implementationTypeUid == TUid::Uid(KUidVideoEncoder)) 

				|| implementationTypeUid == TUid::Uid(KUidVideoDecoder)) 

				{

				TRAP(error, parse = CCodecApiVideoOpaqueData::NewL(impData.OpaqueData()));

				}	

			else

				{

				error = KErrNotSupported;	

				}

			} 

		CleanupStack::PushL(parse);	

		if (error)

			{

			if ((error == KErrNotSupported) || (error == KErrCorrupt))

				{

				// means that the resource entry was not valid

				// we ignore this plugin and try the next one

				CleanupStack::PopAndDestroy(parse);

				continue;

				}

			else

				{

				User::Leave(error);

				}				

			} //end of 	if (error!=KErrNone)

		// check if the uids are different. If they are, move to the next element

		// in the list		

		if (implementationTypeUid != parse->TypeUid())

			{

			CleanupStack::PopAndDestroy(parse);

			continue;

			}

		switch(matchType)

			{	

			// check that the input data type is what we are looking for

			case EMatchInputDataFormat:

				if (parse->CompareInputDataType(customMatch->InputDataFormat()))

					{

					matchFound = ETrue;

					}

				break;

			// check that the output data type is what we are looking for	

			case EMatchOutputDataFormat:

				if (parse->CompareOutputDataType(customMatch->OutputDataFormat()))

					{

					matchFound = ETrue;

					}

				break;

			// check that the input and output data type is what we are looking for	

			case EMatchInputAndOutputDataFormat:

				if (parse->CompareInputDataType(customMatch->InputDataFormat()) 

					&& parse->CompareOutputDataType(customMatch->OutputDataFormat()))

					{

					matchFound = ETrue;

					}

				break;

			default:

				{

				//matchFound was initialised to EFalse, so fall through				

				}				

			}

		// if a match was found, it will be appended to the list returned by this method

		if (matchFound)

			{

			User::LeaveIfError(retList->Append(fullList[index]));	

			}

		CleanupStack::PopAndDestroy(parse);

		} // end of for

	CleanupStack::PopAndDestroy(customMatch);

	CleanupStack::Pop(2, retList);

	return retList;	

	}