// Copyright (c) 2002-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 <badesca.h>

#include <utf.h>

#include <uri8.h>

#include <uriutils.h>

#include <mmf/plugin/mmfplugininterfaceuids.hrh>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "mmfmatchdata.h"

#include <mmf/server/mmfdatasourcesink.hrh>

#include "MMFFormatImplementationInformationBody.h"

#include <mm/mmpluginutils.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <mmf/common/taggeddataparser.h>

#endif

_LIT8(KSupplier, "<s>");

_LIT8(KMediaId, "<i>");

_LIT8(KUriScheme,"<u>");

_LIT8(KNonNetwork,"<n>");

_LIT8(KPlayFormatCollectionUid, "<p>");

_LIT8(KRecordFormatCollectionUid, "<r>");

_LIT8(KFormatFileExtension, "<e>");

_LIT8(KFormatMimeType, "<m>");

_LIT8(KFormatHeaderData, "<h>");

_LIT8(KHeapSize, "<a>");

_LIT8(KCustomInterfaceSupport, "<c>");

_LIT8(KSecureDRMProcessMode, "<d>");

_LIT8(KStackSize, "<t>");

_LIT8(KTagMatch, "*<?>*");

_LIT8(KTagYes,"yes");

const TInt KTagLength = 3;

const TInt KMaxExtLen = 5 ;

const TInt KDesCArrayGranularity = 1;

const TInt KUriPriorityHigh = 3;

const TInt KUriPriorityMedium = 2;

const TInt KUriPriorityLow = 1;

const TInt KUriPriorityNone = 0;

static const TUid KUidInterfaceFormatDecode = {KMmfUidPluginInterfaceFormatDecode};

static const TUid KUidInterfaceFormatEncode = {KMmfUidPluginInterfaceFormatEncode};

static const TUid KUidInterfaceMMFController = {KMmfUidPluginInterfaceController};

EXPORT_C CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewL()

	{

	CMMFFormatSelectionParameters* s = CMMFFormatSelectionParameters::NewLC();

	CleanupStack::Pop(s);

	return s;

	}

EXPORT_C CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewLC()

	{

	CMMFFormatSelectionParameters* s = new(ELeave) CMMFFormatSelectionParameters;

	CleanupStack::PushL(s);

	return s;

	}

CMMFFormatSelectionParameters* CMMFFormatSelectionParameters::NewL(const CMMFFormatSelectionParameters& aParams)

	{

	CMMFFormatSelectionParameters* s = CMMFFormatSelectionParameters::NewLC();

	s->ConstructL(aParams);

	CleanupStack::Pop(s);

	return s;

	}

void CMMFFormatSelectionParameters::ConstructL(const CMMFFormatSelectionParameters& aParams)

	{

	iMatchReqData = CMatchData::CreateL();

	iMatchReqData->SetMatchDataL(aParams.MatchData());

	iMatchReqData->SetMatchUriSchemeL(aParams.MatchUriScheme());

	iMatchDataType = aParams.MatchDataType();

	}

CMMFFormatSelectionParameters::~CMMFFormatSelectionParameters()

	{

	delete iMatchReqData;

	iMatchReqData= NULL;

	}

CMMFFormatSelectionParameters::CMMFFormatSelectionParameters()

	{

	iMatchDataType = EMatchAny;

	}

EXPORT_C void CMMFFormatSelectionParameters::SetMatchToFileNameL(const TDesC& aFileName)

	{

	delete iMatchReqData;

	iMatchReqData = NULL;

	iMatchDataType = EMatchAny;	

	// Extract the extension from the data passed in

	// Parse the path and extract the extension

	_LIT( KDot, "." ) ;

	_LIT8( KDot8, "." );

	// If there is no dot "." in aFileName then assume that we have been passed the extension only (if KMaxExtLen or less)

	if ( (aFileName.Length() <= KMaxExtLen) && (aFileName.Find( KDot ) == KErrNotFound) )

		{

		RBuf8 temp;

		CleanupClosePushL(temp);

		temp.CreateL(aFileName.Length()+1);

		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, aFileName));

		temp.Insert(0,KDot8);

		iMatchReqData = CMatchData::CreateL();

		iMatchReqData->SetMatchDataL(temp);

		CleanupStack::PopAndDestroy(&temp);

		}

	else if ( aFileName.Find( KDot ) == 0 )  // the first character is dot so assume extension only

		{

		RBuf8 temp;

		CleanupClosePushL(temp);

		temp.CreateL(aFileName.Length());

		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, aFileName));

		iMatchReqData = CMatchData::CreateL();

		iMatchReqData->SetMatchDataL(temp);

		CleanupStack::PopAndDestroy(&temp);

		}

	else // We have been given the whole filename.  Use TParse to extract the extension.

		{

		TParse parser ;

		parser.Set( aFileName, NULL, NULL ) ;

		if ( !( parser.NamePresent() ) )

			User::Leave( KErrBadName ) ;

		if ( !( parser.PathPresent() ) )

			{

			RFs fsSession ;

			User::LeaveIfError(fsSession.Connect());

			TInt error = fsSession.Parse(aFileName, parser);

			fsSession.Close();

			User::LeaveIfError(error);

			}

		// Parser should now have the full filename and path

		TPtrC extension = parser.Ext();

		RBuf8 temp;

		CleanupClosePushL(temp);

		temp.CreateL(extension.Length());

		User::LeaveIfError(CnvUtfConverter::ConvertFromUnicodeToUtf8(temp, extension));

		iMatchReqData = CMatchData::CreateL();

		iMatchReqData->SetMatchDataL(temp);

		CleanupStack::PopAndDestroy(&temp);

		}

	// If we're here, we must now have the file extension

	iMatchDataType = EMatchFileExtension;

	}

EXPORT_C void CMMFFormatSelectionParameters::SetMatchToUriL(const TDesC& aUrl)

	{

	delete iMatchReqData;

	iMatchReqData = NULL;

	iMatchDataType = EMatchAny;	

	CUri8* uri = UriUtils::CreateUriL(aUrl); //Converts the TDesC16 aUrl to TDesC8 type

   	CleanupStack::PushL(uri);

  	const TDesC8& path = uri->Uri().Extract(EUriPath);

	// Now parse the file name 

   	TInt pos = path.LocateReverse('.');

   	if(pos != KErrNotFound) // if not found, then by default match data is NULL

   		{

   		TPtrC8 extension(path.Right(path.Length()-pos));

   		iMatchReqData = CMatchData::CreateL();

   		iMatchReqData->SetMatchDataL(extension);

  		}

   	CleanupStack::PopAndDestroy(uri);

   	// If we're here, we must now have the file extension

   	// Use match file extension, because we are matching to the file extension of the file specified by the URI

  	iMatchDataType = EMatchFileExtension;

	}

/**

	@publishedPartner

	@prototype

	Sets this object to match to uri scheme and file extension specified by a URI.

	The Uri scheme and extension are saved in iMatchReqData. Further,iMatchData contains uri extension, 

	iMatchUriScheme contains uri scheme.

	@param  aUri

	        The URI containing the scheme and uri extension to be matched. 

*/	

EXPORT_C void CMMFFormatSelectionParameters::SetMatchToUriSupportL(const TDesC& aUrl)

	{

	delete iMatchReqData;

	iMatchReqData = NULL;

	iMatchDataType = EMatchAny;	

	CUri8* uri = UriUtils::CreateUriL(aUrl); //Converts the TDesC16 aUrl to TDesC8 type

	CleanupStack::PushL(uri);

	const TDesC8& scheme = uri->Uri().Extract(EUriScheme);  //get the uri scheme

	iMatchReqData = CMatchData::CreateL();

	iMatchReqData->SetMatchUriSchemeL(scheme);

	const TDesC8& path = uri->Uri().Extract(EUriPath); 		

	// Now parse the file name 

	TInt pos = path.LocateReverse('.');

	if(pos != KErrNotFound) // if not found, by default match data is NULL

		{

		TPtrC8 extension(path.Right(path.Length()-pos));

		iMatchReqData->SetMatchDataL(extension);

 		}

	CleanupStack::PopAndDestroy(uri);

	// If we're here, we must now have the uri saved in iMatchData. Now, set match type 

	// to EMatchUri for checking schema and uri extension

	iMatchDataType = EMatchUri;

	}

EXPORT_C void CMMFFormatSelectionParameters::SetMatchToMimeTypeL(const TDesC8& aMimeType)

	{

	delete iMatchReqData;

	iMatchReqData = NULL;

	iMatchDataType = EMatchAny;	

	iMatchReqData = CMatchData::CreateL();

	iMatchReqData->SetMatchDataL(aMimeType);

	iMatchDataType = EMatchMimeType;

	}

EXPORT_C void CMMFFormatSelectionParameters::SetMatchToHeaderDataL(const TDesC8& aHeaderData)

	{

	delete iMatchReqData;

	iMatchReqData = NULL;

	iMatchDataType = EMatchAny;	

	iMatchReqData = CMatchData::CreateL();

	iMatchReqData->SetMatchDataL(aHeaderData);	

	iMatchDataType = EMatchHeaderData;

	}

EXPORT_C const TDesC8& CMMFFormatSelectionParameters::MatchData() const

	{

	if (iMatchReqData)

		{

		return iMatchReqData->MatchData();

		}

	else

		{

		return KNullDesC8;	

		}

	}

/**

	@publishedPartner

	@prototype

	Returns the uri scheme used to perform the plugin match.

	@return The uri scheme.

*/	

EXPORT_C const TDesC8& CMMFFormatSelectionParameters::MatchUriScheme() const

	{

	if (iMatchReqData)

		{

		return iMatchReqData->MatchUriScheme();

		}

	else

		{

		return KNullDesC8;

		}

	}

EXPORT_C CMMFFormatSelectionParameters::TMatchDataType CMMFFormatSelectionParameters::MatchDataType() const

	{

	return iMatchDataType;

	}

CMMFPluginSelectionParameters::CMMFPluginSelectionParameters(TUid aPluginInterfaceUid) :

	iPluginInterfaceUid(aPluginInterfaceUid)

	{

	iPreferredSupplierMatchType = ENoPreferredSupplierMatch;

	iMediaIdMatchType = ENoMediaIdMatch;

	}

CMMFPluginSelectionParameters::~CMMFPluginSelectionParameters()

	{

	delete iPreferredSupplier;

	iMediaIds.Reset();

	iMediaIds.Close();

	}

EXPORT_C void CMMFPluginSelectionParameters::SetPreferredSupplierL(const TDesC& aPreferredSupplier, TPreferredSupplierMatchType aMatchType)

	{

	delete iPreferredSupplier;

	iPreferredSupplier = NULL;

	iPreferredSupplier = aPreferredSupplier.AllocL();

	iPreferredSupplierMatchType = aMatchType;

	}

EXPORT_C void CMMFPluginSelectionParameters::SetMediaIdsL(const RArray<TUid>& aMediaIds, TMediaIdMatchType aMatchType)

	{

	iMediaIds.Reset();

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

		{

		User::LeaveIfError(iMediaIds.Append(aMediaIds[i]));

		}

	iMediaIdMatchType = aMatchType;

	}

EXPORT_C const TDesC& CMMFPluginSelectionParameters::PreferredSupplier() const

	{

	if (iPreferredSupplier)

		return *iPreferredSupplier;

	else

		return KNullDesC;

	}

EXPORT_C CMMFPluginSelectionParameters::TPreferredSupplierMatchType CMMFPluginSelectionParameters::PreferredSupplierMatchType() const

	{

	return iPreferredSupplierMatchType;

	}

EXPORT_C const RArray<TUid>& CMMFPluginSelectionParameters::MediaIds() const

	{

	return iMediaIds;

	}

EXPORT_C CMMFPluginSelectionParameters::TMediaIdMatchType CMMFPluginSelectionParameters::MediaIdMatchType() const

	{

	return iMediaIdMatchType;

	}

EXPORT_C TUid CMMFPluginSelectionParameters::InterfaceUid() const

	{

	return iPluginInterfaceUid;

	}

TBool CMMFPluginSelectionParameters::CheckMediaIdSupportL(const CMMFPluginImplementationInformation& aPlugin) const

	{

	TBool ret = EFalse;

	switch (MediaIdMatchType())

		{

	case CMMFPluginSelectionParameters::ENoMediaIdMatch:

		// No match required so suitable

		ret = ETrue;

		break;

	case CMMFPluginSelectionParameters::EAllowOtherMediaIds:

		// Just check that the requested media id is supported by the plugin

		{

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

			{

			if (aPlugin.SupportsMediaId(MediaIds()[i]))

				{

				ret = ETrue;

				break;

				}

			}

		break;

		}

	case CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds:

		// Check the media id counts are the same, and that all requested ones are present

		{

		TInt found=0;

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

			{

			if (aPlugin.SupportsMediaId(MediaIds()[i]))

				found++;

			}

		// Check all request mediaIds are present

		if ((found == MediaIds().Count()) && (found == aPlugin.SupportedMediaIds().Count()))

			ret = ETrue;

		break;

		}

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

EXPORT_C CMMFControllerPluginSelectionParameters* CMMFControllerPluginSelectionParameters::NewL()

	{

	CMMFControllerPluginSelectionParameters* s = CMMFControllerPluginSelectionParameters::NewLC();

	CleanupStack::Pop(s);

	return s;	

	}

EXPORT_C CMMFControllerPluginSelectionParameters* CMMFControllerPluginSelectionParameters::NewLC()

	{

	CMMFControllerPluginSelectionParameters* s = new(ELeave) CMMFControllerPluginSelectionParameters;

	CleanupStack::PushL(s);

	return s;

	}

CMMFControllerPluginSelectionParameters::CMMFControllerPluginSelectionParameters() :

	CMMFPluginSelectionParameters(KUidInterfaceMMFController)

	{

	}

CMMFControllerPluginSelectionParameters::~CMMFControllerPluginSelectionParameters()

	{

	delete iRequiredPlayFormatSupport;

	delete iRequiredRecordFormatSupport;

	}

EXPORT_C void CMMFControllerPluginSelectionParameters::SetRequiredPlayFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

	{

	delete iRequiredPlayFormatSupport;

	iRequiredPlayFormatSupport = NULL;

	iRequiredPlayFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

	}

EXPORT_C void CMMFControllerPluginSelectionParameters::SetRequiredRecordFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

	{

	delete iRequiredRecordFormatSupport;

	iRequiredRecordFormatSupport = NULL;

	iRequiredRecordFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

	}

EXPORT_C void CMMFControllerPluginSelectionParameters::ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const

	{

	aImplementations.ResetAndDestroy();

	RImplInfoPtrArray ecomArray;

	CleanupResetAndDestroyPushL(ecomArray);

	MmPluginUtils::FindImplementationsL(InterfaceUid(), ecomArray);

	TInt index;

	// Create Controller Implementation Information for each entry

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

		{

		CMMFControllerImplementationInformation* c = NULL;

		if (ecomArray[index] == NULL)

			{

			User::Leave(KErrNoMemory);

			}

		TRAPD(error, c = CMMFControllerImplementationInformation::NewL(*(ecomArray[index])));

		if (error == KErrNone)

			{

			CleanupStack::PushL(c);

		// If required, get the play and record formats for the controller.

			if (iRequiredPlayFormatSupport)

				{

				c->GetPlayFormatsL();

				}

			if (iRequiredRecordFormatSupport)

				{

				c->GetRecordFormatsL();

				}

			// Find out whether this controller matches the client's requirements...

			TBool suitable = EFalse;

			TInt arrayPos; 

			suitable = CheckUriSupport(iRequiredPlayFormatSupport, c, c->PlayFormats());

			if(suitable)

				{

				suitable = CheckUriSupport(iRequiredRecordFormatSupport, c, c->RecordFormats());

				}

			if(suitable)

				{

				MatchImplementationToSelectParamsL(aImplementations, *c, arrayPos);

				}

			else

				{

				arrayPos = -1;	

				}

			if (arrayPos >=0)

				{

				// This plugin is suitable - insert it into the array at the suggested position

				User::LeaveIfError(aImplementations.Insert(c, arrayPos));

				CleanupStack::Pop(c);

				}

			else

				{

				// This plugin isn't suitable so just destroy it

				CleanupStack::PopAndDestroy(c);

				}

			}

		else if (error != KErrCorrupt)

			{

			// Ignore the plugin if it is corrupt.  Otherwise, leave.

			// if error !=KErrNone, c hasn't been constructed so it is safe to leave

			User::Leave(error);

			}

		}

	CleanupStack::PopAndDestroy();//ecomArray

	}

void CMMFControllerPluginSelectionParameters::MatchImplementationToSelectParamsL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin, TInt& aArrayPos) const

	{

	TBool suitable = EFalse;

	// First, check whether the plugin supports the required play formats

	suitable = CheckFormatSupportL(iRequiredPlayFormatSupport, aPlugin.PlayFormats());

	// Next, check the record formats

	if (suitable)

		suitable = CheckFormatSupportL(iRequiredRecordFormatSupport, aPlugin.RecordFormats());

	// Next, check for correct media id support

	if (suitable)

		suitable = CheckMediaIdSupportL(aPlugin);

	// Finally, calculate the position the plugin should take in aImplementations depending on the preferred supplier and version number.

	if (suitable)

		aArrayPos = CheckPreferredSupplierL(aImplementations, aPlugin);

	else

		aArrayPos = -1;

	}

/**

	Checks the given Controller for uri support. Uri support may be there 

	if either requiredscheme or extension matches with that given controller

	@param  aSelectParams 

			Describes the selection parameter which a controller needs to 

			support in order to be selected

	@param	aPlugin

			The controller plugin which is checked for uri support 

	@param	aFormats

			The play or record formats looked for extension match

*/	

TBool CMMFControllerPluginSelectionParameters::CheckUriSupport(CMMFFormatSelectionParameters* aSelectParams, CMMFControllerImplementationInformation* aPlugin, const RMMFFormatImplInfoArray& aFormats) const

	{

	// If aSelectParams are NULL (ie none were set) then the plugin must be suitable!

	if (aSelectParams == NULL)

		return ETrue;

	//If EMatchUri not set then the plugin might be suitable!

	if(aSelectParams->MatchDataType() != CMMFFormatSelectionParameters::EMatchUri)

		{

		return ETrue;

		}

	TBool suitable = EFalse;

	TInt index;

	//If <n>yes is there in the aPlugin's opaque data, 

	//URI support not assumed. So, don't load the controller

	if(!aPlugin->SupportsNetworkCapability())

		{

		return EFalse;	

		}

    //the uri scheme to be matched for

	if (aPlugin->SupportsUriScheme(aSelectParams->MatchUriScheme()))

		{

		aPlugin->SetUriPriority(KUriPriorityMedium);

		suitable = ETrue;

		}

	else

		{

		//if other uri scheme support declared, but not the required one,

		// even then controller not supported

		if(aPlugin->SupportedUriSchemes().Count() > 0)

			{

			return EFalse;		

			}

		}

	//then match Uri extension. .

	//if ctrl has no network capability, then lowest priority given on matching file extension

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

		{

		if (aFormats[index]-> SupportsFileExtension(aSelectParams->MatchData()))

			{

			if(!suitable)

				{

				aPlugin->SetUriPriority(KUriPriorityLow);	

				}

			else

				{

				aPlugin->SetUriPriority(KUriPriorityHigh);

				}

			suitable = ETrue;

			break;

			}

		}

	return suitable;

	}

TInt CMMFControllerPluginSelectionParameters::CheckPreferredSupplierL(RMMFControllerImplInfoArray& aImplementations, const CMMFControllerImplementationInformation& aPlugin) const

	{

	// Set the return value to indicated the plugin is not suitable.

	TBool pluginSuitable = EFalse;

	TBool needToPlaceInVersionOrder = EFalse;

	TBool needToPlaceInUriPriorityOrder = EFalse;

	if((iRequiredPlayFormatSupport && (iRequiredPlayFormatSupport->MatchDataType() == CMMFFormatSelectionParameters::EMatchUri))

	 || (iRequiredRecordFormatSupport && (iRequiredRecordFormatSupport->MatchDataType() == CMMFFormatSelectionParameters::EMatchUri)))

		{

		needToPlaceInUriPriorityOrder = ETrue;

		}

	switch (PreferredSupplierMatchType())

		{

	case ENoPreferredSupplierMatch:

		// No match, so suitable.

		pluginSuitable = ETrue;

	    break;

	case EPreferredSupplierPluginsFirstInList:

		pluginSuitable = ETrue;

		if (aPlugin.SupportsSupplier(PreferredSupplier()))

			needToPlaceInVersionOrder = ETrue;

		break;

	case EOnlyPreferredSupplierPluginsReturned:

		if (aPlugin.SupportsSupplier(PreferredSupplier()))

			{

			pluginSuitable = ETrue;

			needToPlaceInVersionOrder = ETrue;

			}

		break;

	default:

		User::Leave(KErrNotSupported);

		}

	TInt arrayPos;

	if (!pluginSuitable)

		{

		arrayPos = -1;

		}

	else

		{

		if(needToPlaceInUriPriorityOrder)

			{

			arrayPos = aImplementations.Count();

			// Cycle through aImplementations to find the first plugin with a uri priority LOWER than aPlugin's

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

				{

				CMMFControllerImplementationInformation* c = aImplementations[i];

				if(PreferredSupplierMatchType() == ENoPreferredSupplierMatch) //case 1

					{

					/**

					Place the plugin based on its Uri priority.

					Arrange the plugins in Decreasing order of their priority. In case if two or more plugins 

					have similar priority, append the next one at the end. 

					*/

					if (c->UriPriority() < aPlugin.UriPriority())

						{

						arrayPos = i;//plugin will be inserted before c in the array

						break;

						}

					}

				else

					{

					if(!needToPlaceInVersionOrder)  //case 2

						{

						/**

						This reflects the case EPreferredSupplierPluginsFirstInList and 

						aPlugin supplier not matching.

						Place the plugin based on its Uri Priority after the required suppliers plugin.

						If priority is equal, new plugin will be placed last.

						*/

						if( (c->Supplier() != PreferredSupplier()) && (c->UriPriority() < aPlugin.UriPriority()))

							{

							arrayPos = i;//plugin will be inserted before c in the array

							break;

							}

						}

					else  //case 3

						{

						/** 

						This reflects the case where 

						Supplier matches and EPreferredSupplierPluginsFirstInList is specified.

						OR

						Supplier matches and EOnlyPreferredSupplierPluginsReturned is specified.

						*/

						if(c->Supplier() == PreferredSupplier()) 

							{

							if(c->UriPriority() == aPlugin.UriPriority())

								{

								if(c->Version() <= aPlugin.Version())

									{

									arrayPos = i;//plugin will be inserted before c in the array

									break;

									}

								}

							else 

								{

								if(c->UriPriority() < aPlugin.UriPriority())

									{

									arrayPos = i;//plugin will be inserted before c in the array

									break;

									}

								}

							}

						else

							{

							/**

							This is a case of aImplementations now having unpreferred suppliers 

							when EPreferredSupplierPluginsFirstInList is specified and aPlugin is

							of preferred supplier but least priority.

							*/

							arrayPos = i;//plugin will be inserted before c in the array

							break;

							}

						}

					}

				}

			}

		else

			{

			if (!needToPlaceInVersionOrder)  

				{

				/**

				place it at the end.

				*/

				arrayPos = aImplementations.Count();

				}

			else

				{

				// Insert the plugin at the beginning of the array, in version order if possible.

				// Make an assumption: if we've been asked for format support, then only plugins 

				// that support the same format will be in the array - so ordering them by version

				// will be meaningful.  Otherwise, there's no point.

				if ((iRequiredPlayFormatSupport && (iRequiredPlayFormatSupport->MatchDataType() != CMMFFormatSelectionParameters::EMatchAny))

					|| (iRequiredRecordFormatSupport && (iRequiredRecordFormatSupport->MatchDataType() != CMMFFormatSelectionParameters::EMatchAny)))

					{

					// Put the plugin in version order at the beginning of the list

					// Set aArrayPos to the end of the array in case this plugin has the lowest version number

					arrayPos = aImplementations.Count();

					// Cycle through aImplementations to find the first plugin with a version number LOWER than aPlugin

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

						{

						CMMFControllerImplementationInformation* c = aImplementations[i];

						if (c->Supplier() == aPlugin.Supplier())

							{

							if (c->Version() <= aPlugin.Version())

								{

								arrayPos = i;//plugin will be inserted before c in the array

								break;

								}

							}

						else

							{

							arrayPos = i; //c has wrong supplier so this plugin must go before c

							break;

							}

						}

					}

				else

					{

					// We can't use the version numbers meaningfully, so just put this plugin

					// at the top of the list.

					arrayPos = 0;

					}

				}

			}

		}

	return arrayPos;

	}

TBool CMMFControllerPluginSelectionParameters::CheckFormatSupportL(CMMFFormatSelectionParameters* aSelectParams, const RMMFFormatImplInfoArray& aFormats) const

	{

	// If aSelectParams are NULL (ie none were set) then the plugin must be suitable!

	if (aSelectParams == NULL)

		return ETrue;

	TBool suitable = EFalse;

	// Check all the formats in aFormats.  If any support the required data type, return ETrue.

	TInt index;

	switch (aSelectParams->MatchDataType())

		{

	case CMMFFormatSelectionParameters::EMatchAny:

		// All plugins intrinsically match this!

		suitable = ETrue;

		break;

	case CMMFFormatSelectionParameters::EMatchFileExtension:

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

			{

			if (aFormats[index]->SupportsFileExtension(aSelectParams->MatchData()))

				{

				suitable = ETrue;

				break;

				}

			}

		break;

	case CMMFFormatSelectionParameters::EMatchMimeType:

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

			{

			if (aFormats[index]->SupportsMimeType(aSelectParams->MatchData()))

				{

				suitable = ETrue;

				break;

				}

			}

		break;

	case CMMFFormatSelectionParameters::EMatchHeaderData:

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

			{

			if (aFormats[index]->SupportsHeaderDataL(aSelectParams->MatchData()))

				{

				suitable = ETrue;

				break;

				}

			}

		break;

	case CMMFFormatSelectionParameters::EMatchUri:

		{

		suitable = ETrue; //if uri match specifically looked , then that has been already matched in a CheckUriSupport()

		break;	

		}

	default:

		User::Leave(KErrNotSupported);

		};

	return suitable;

	}

EXPORT_C CMMFControllerSecureDrmPluginSelectionParameters* CMMFControllerSecureDrmPluginSelectionParameters::NewL()

	{

	CMMFControllerSecureDrmPluginSelectionParameters* s = CMMFControllerSecureDrmPluginSelectionParameters::NewLC();

	CleanupStack::Pop(s);

	return s;	

	}

EXPORT_C CMMFControllerSecureDrmPluginSelectionParameters* CMMFControllerSecureDrmPluginSelectionParameters::NewLC()

	{

	CMMFControllerSecureDrmPluginSelectionParameters* s = new(ELeave) CMMFControllerSecureDrmPluginSelectionParameters;

	CleanupStack::PushL(s);

	return s;

	}

CMMFControllerSecureDrmPluginSelectionParameters::CMMFControllerSecureDrmPluginSelectionParameters() :

	CMMFControllerPluginSelectionParameters()

	{

	}

EXPORT_C void CMMFControllerSecureDrmPluginSelectionParameters::ListImplementationsL(RMMFControllerImplInfoArray& aImplementations) const

	{

	CMMFControllerPluginSelectionParameters::ListImplementationsL(aImplementations);

	TInt pluginsCount = aImplementations.Count();

	for (TInt i = pluginsCount - 1; i >= 0; i--)

		{

		CMMFControllerImplementationInformation* c = aImplementations[i];

		if (!c->SupportsSecureDRMProcessMode())

			{

			aImplementations.Remove(i);

			delete c;

			}

		}

	aImplementations.Compress();

	}

CMMFFormatPluginSelectionParameters::CMMFFormatPluginSelectionParameters(TUid aInterfaceUid) :

	CMMFPluginSelectionParameters(aInterfaceUid)

	{

	}

CMMFFormatPluginSelectionParameters::~CMMFFormatPluginSelectionParameters()

	{

	delete iRequiredFormatSupport;

	}

EXPORT_C void CMMFFormatPluginSelectionParameters::SetRequiredFormatSupportL(const CMMFFormatSelectionParameters& aRequiredSupport)

	{

	delete iRequiredFormatSupport;

	iRequiredFormatSupport = NULL;

	iRequiredFormatSupport = CMMFFormatSelectionParameters::NewL(aRequiredSupport);

	}

EXPORT_C void CMMFFormatPluginSelectionParameters::ListImplementationsL(RMMFFormatImplInfoArray& aImplementations) const

	{

	aImplementations.ResetAndDestroy();

	RImplInfoPtrArray ecomArray;

	CleanupResetAndDestroyPushL(ecomArray);

	MmPluginUtils::FindImplementationsL(InterfaceUid(), ecomArray);

	TInt index;

	// Create Format Implementation Information for each entry

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

		{

		CMMFFormatImplementationInformation* c = NULL;

		TRAPD(error, c = CMMFFormatImplementationInformation::NewL(*(ecomArray[index])));

		if (error == KErrNone)

			{

			CleanupStack::PushL(c);

			// Find out whether this format matches the client's requirements...

			TInt arrayPos;

			MatchImplementationToSelectParamsL(aImplementations, *c, arrayPos);

			if (arrayPos >=0)

				{

				// This plugin is suitable - insert it into the array at the suggested position

				User::LeaveIfError(aImplementations.Insert(c, arrayPos));

				CleanupStack::Pop(c);

				}

			else

				{

				// This plugin isn't suitable so just destroy it

				CleanupStack::PopAndDestroy(c);

				}

			}

		else if (error != KErrCorrupt)

			{

			// Ignore the plugin if it is corrupt.  Otherwise, leave.

			// if error !=KErrNone, c hasn't been constructed so it is safe to leave

			User::Leave(error);

			}

		}

	CleanupStack::PopAndDestroy();//ecomArray

	}

void CMMFFormatPluginSelectionParameters::MatchImplementationToSelectParamsL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin, TInt& aArrayPos) const

	{

	TBool suitable = EFalse;

	// First, check whether the plugin supports the required play formats

	suitable = CheckFormatSupportL(aPlugin);

	// Next, check for correct media id support

	if (suitable)

		suitable = CheckMediaIdSupportL(aPlugin);

	// Finally, calculate the position the plugin should take in aImplementations depending on the preferred supplier and version number.

	if (suitable)

		aArrayPos = CheckPreferredSupplierL(aImplementations, aPlugin);

	else

		aArrayPos = -1;

	}

TInt CMMFFormatPluginSelectionParameters::CheckPreferredSupplierL(RMMFFormatImplInfoArray& aImplementations, const CMMFFormatImplementationInformation& aPlugin) const

	{

	// Set the return value to indicated the plugin is not suitable.

	TBool pluginSuitable = EFalse;

	TBool needToPlaceInVersionOrder = EFalse;

	switch (PreferredSupplierMatchType())

		{

	case ENoPreferredSupplierMatch:

		// No match, so suitable.

		pluginSuitable = ETrue;

		break;

	case EPreferredSupplierPluginsFirstInList:

		pluginSuitable = ETrue;