// 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;	
	}