// MmPluginUtils.cpp

// 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 <mm/mmpluginutils.h>

#include <mm/mmcleanup.h>

//

// MmPluginUtils

//

/**

Find a plugin with the requested interfaceUid and whose match string matches

the default data field. Where there are more than one plugin, choose that

with highest version no.

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TInt32 aKeyOffset, 

									                const TDesC8& aDefaultData,

									                TUid aResolverUid)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray, aDefaultData, aResolverUid);

	// Get higher version implementation

	TAny* higherversionplugin = GetHigherVersionImplementationKeyOffsetL(pluginArray,aKeyOffset);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/**

Find a plugin with the requested interfaceUid and whose match string matches

the default data field. Where there are more than one plugin, choose that

with highest version no.

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TInt32 aKeyOffset, 

									                const TDesC8& aDefaultData)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray, aDefaultData);

	// Get higher version implementation

	TAny* higherversionplugin = GetHigherVersionImplementationKeyOffsetL(pluginArray,aKeyOffset);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/**

Find a plugin with the requested interfaceUid and whose match string matches

the default data field. Where there are more than one plugin, choose that

with highest version no.

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TInt32 aKeyOffset)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray);

	// Get higher version implementation

	TAny* higherversionplugin = GetHigherVersionImplementationKeyOffsetL(pluginArray,aKeyOffset);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/**

Get the higher version of plugin passing keyoffset

*/

TAny* MmPluginUtils::GetHigherVersionImplementationKeyOffsetL(RImplInfoPtrArray& pluginArray, TInt32 aKeyOffset)

	{

	TAny* self = NULL;

	if (pluginArray.Count() == 0)

		{

		User::Leave(KErrNotSupported);

		}

	else if (pluginArray.Count() == 1)

    	{

		self = REComSession::CreateImplementationL(pluginArray[0]->ImplementationUid(), aKeyOffset);

    	}

	else 

		{

		// create each in turn, starting with the highest version, which is the start element

		for (TInt index = 0;  index < pluginArray.Count(); index++)

			{

			TInt err=KErrNone;

			self = NULL;

			TRAP(err, self = REComSession::CreateImplementationL(pluginArray[index]->ImplementationUid(), aKeyOffset))

			if (err == KErrNone)

		    	{

		    	break;

		    	}

			if (err != KErrNotSupported)

				{

				User::Leave(err);

				}

			}

		if (!self)

			{

			User::Leave(KErrNotSupported);

			}

		}

	return self;		

	}

/*

Similar but return destructor key via reference

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TUid& aDestructorKey,

									                const TDesC8& aDefaultData,

									                TUid aResolverUid)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray, aDefaultData, aResolverUid);

    // Get higher version implementation

    TAny* higherversionplugin = GetHigherVersionImplementationaDestructorKeyL(pluginArray, aDestructorKey);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/*

Similar but return destructor key via reference

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TUid& aDestructorKey,

									                const TDesC8& aDefaultData)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray, aDefaultData);

	// Get higher version implementation

    TAny* higherversionplugin = GetHigherVersionImplementationaDestructorKeyL(pluginArray, aDestructorKey);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/*

Similar but return destructor key via reference

*/

EXPORT_C TAny* MmPluginUtils::CreateImplementationL(TUid aInterfaceUid, 

									                TUid& aDestructorKey)

	{

	RImplInfoPtrArray pluginArray;

	CleanupResetAndDestroyPushL(pluginArray);

	FindImplementationsL(aInterfaceUid, pluginArray);

	// Get higher version implementation

    TAny* higherversionplugin = GetHigherVersionImplementationaDestructorKeyL(pluginArray, aDestructorKey);

	CleanupStack::PopAndDestroy(&pluginArray);

	return higherversionplugin;	

	}

/**

Get the higher version of plugin passing destructorkey

*/

TAny* MmPluginUtils::GetHigherVersionImplementationaDestructorKeyL(RImplInfoPtrArray& pluginArray, TUid& aDestructorKey)

	{

	TAny* self = NULL;

	if (pluginArray.Count() == 0)

		{

		User::Leave(KErrNotSupported);

		}

	else if (pluginArray.Count() == 1)

    	{

		self = REComSession::CreateImplementationL(pluginArray[0]->ImplementationUid(), aDestructorKey);

    	}

	else 

		{

		// create each in turn, starting with the highest version, which is the start element

		for (TInt index = 0;  index < pluginArray.Count(); index++)

			{

			TInt err = KErrNone;

			self = NULL;

			TRAP(err, self = REComSession::CreateImplementationL(pluginArray[index]->ImplementationUid(), aDestructorKey))

		    if (err == KErrNone)

		    	{

		    	break;

		    	}

			if (err != KErrNotSupported)

				{

				User::Leave(err);

				}

			}

		if (!self)

			{

			User::Leave(KErrNotSupported);

			}

		}

	return self;		

	}

/*

The function is an implementation of the templated TLinearOrder so it can order implementation information

in an increasing version number.

*/

TInt VersionLinearOrderFunction(const CImplementationInformation& pluginA, 

                                const CImplementationInformation& pluginB)

	{

	if (pluginA.Version() == pluginB.Version())

		{

		return 0;

		}

	return (pluginA.Version() < pluginB.Version())? 1: -1;	

	}

EXPORT_C void MmPluginUtils::FindImplementationsL(TUid aInterfaceUid, 

						                RImplInfoPtrArray& aPluginArray)

	{

	REComSession::ListImplementationsL(aInterfaceUid, aPluginArray);

	CheckAndSortL(aPluginArray);

	}

EXPORT_C void MmPluginUtils::FindImplementationsL(TUid aInterfaceUid, 

						                RImplInfoPtrArray& aPluginArray, 

				                        const TDesC8& aDefaultData,

						                TUid aResolverUid)

	{

	TEComResolverParams resolverParams;

	resolverParams.SetDataType(aDefaultData);

	FindImplementationsL(aInterfaceUid, aPluginArray, resolverParams, aResolverUid);

	}

EXPORT_C void MmPluginUtils::FindImplementationsL(TUid aInterfaceUid, 

						                RImplInfoPtrArray& aPluginArray, 

				                        const TDesC8& aDefaultData)

	{

	TEComResolverParams resolverParams;

	resolverParams.SetDataType(aDefaultData);

	FindImplementationsL(aInterfaceUid, aPluginArray, resolverParams);

	}

void MmPluginUtils::FindImplementationsL(TUid aInterfaceUid, 

						                RImplInfoPtrArray& aPluginArray, 

				                        TEComResolverParams& aResolverParams)

	{

	REComSession::ListImplementationsL(aInterfaceUid, aResolverParams, aPluginArray);

	CheckAndSortL(aPluginArray);

	}

void MmPluginUtils::FindImplementationsL(TUid aInterfaceUid, 

						                RImplInfoPtrArray& aPluginArray, 

				                        TEComResolverParams& aResolverParams,

						                TUid aResolverUid)

	{

	REComSession::ListImplementationsL(aInterfaceUid, aResolverParams, aResolverUid, aPluginArray);

	CheckAndSortL(aPluginArray);

	}

void MmPluginUtils::CheckAndSortL(RImplInfoPtrArray& aPluginArray)

	{

	// there must be at least one implementation

	if (aPluginArray.Count() > 0)

		{

		if (aPluginArray.Count() > 1)

			{

			aPluginArray.Sort(VersionLinearOrderFunction);

			}

		// if the highest version is zero there is no need to linger -- it should not be supported

		// and we will leave

		if (aPluginArray[0]->Version() == 0)

			{

			// plugins were found to be malformed, with 0 version numbers

			User::Leave(KErrNotSupported);

			}

		}

	}