// 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());