// Copyright (c) 2001-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 <bitdev.h>

#include <bautils.h>

#include <barsc.h>

#include <caf/caf.h>

using namespace ContentAccess;

#include "ImageConversion.h"

#include "ImageClientMain.h"

#include "ImageResolverAPI.h"

#include "ImageUtils.h"

#include "ImageConvResolvrUtils.h"

#include "ImageRelay.h"

#include "icl/ImageConstruct.h"

#include "icl/ImagePlugin.h"

#include "ImageConversion.inl"

#include "ImageCodecBody.h"

#include "EnDecoderUtils.h"

#include "icl/imageconversionextension.h"

#include "fwextconstants.h"

const TInt KMaxMimeLength = 256;

const TInt KMinimumHeaderLength = 2;

//

// CImageTypeDescription

//

/**

Constructs a new image type description entry.

A leave occurs if there is insufficient memory available.

@param  aDescription

        A description of the plugin decoder/encoder.

@param  aImageType

        The plugin decoder/encoder type UID.

@param  aSubType

        The plugin decoder/encoder sub-type UID.

@return A pointer to the new image type description entry.

*/

CImageTypeDescription* CImageTypeDescription::NewL(const TDesC& aDescription, const TUid aImageType, const TUid aSubType)

	{

	CImageTypeDescription* self = CImageTypeDescription::NewLC(aDescription, aImageType, aSubType);

	CleanupStack::Pop();

	return self;

	}

/**

Constructs a new image type description entry. The new object created on the clean-up stack.

A leave occurs if there is insufficient memory available.

@param  aDescription

        A description of the plugin decoder/encoder.

@param  aImageType

        The plugin decoder/encoder type UID.

@param  aSubType

        The plugin decoder/encoder sub-type UID.

@return A pointer to the new image type description entry.

*/

CImageTypeDescription* CImageTypeDescription::NewLC(const TDesC& aDescription, const TUid aImageType, const TUid aSubType)

	{

	CImageTypeDescription* self = new(ELeave) CImageTypeDescription(aImageType, aSubType);

	CleanupStack::PushL(self);

	self->ConstructL(aDescription);

	return self;

	}

/** 

Default constructor. 

@param aImageType 

           The plugin decoder/encoder type UID. 

@param aSubType 

           The plugin decoder/encoder sub-type UID 

*/ 

CImageTypeDescription::CImageTypeDescription(const TUid aImageType, const TUid aSubType)

	: iImageType(aImageType), iSubType(aSubType)

	{

	}

/** 

Second phase constructor. 

@param aDescription 

           A description of the plugin decoder/encoder. 

*/ 

void CImageTypeDescription::ConstructL(const TDesC& aDescription)

	{

	iDescription = aDescription.AllocL();

	}

/**

Destructor.

*/

EXPORT_C CImageTypeDescription::~CImageTypeDescription()

	{

	delete iDescription;

	}

/**

Returns the image description info.

@return  A reference to the descriptor containing the description.

*/

EXPORT_C const TDesC& CImageTypeDescription::Description() const

	{

	return *iDescription;

	}

/**

Returns the image type info.

@return The image type info as a TUid object.

*/

EXPORT_C TUid CImageTypeDescription::ImageType() const

	{

	return iImageType;

	}

/**

Returns the image sub-type information.

@return The image sub-type information as a TUid object.

*/

EXPORT_C TUid CImageTypeDescription::SubType() const

	{

	return iSubType;

	}

//

// CFileExtensionMIMEType

//

/**

Constructs a new file extension/MIME type entry.

A leave occurs if there is insufficient memory available.

@param  aExtn

        The file extension.

@param  aMIMEType

        The associated MIME type.

@param  aDisplayName The display name of the implementation 

@param  aImageType The plugin decoder/encoder type UID. 

@param  aImageSubType The plugin decoder/encoder sub-type UID. 

@param  aImplementationUid The unique ID of the implementation. 

@return A pointer to the new file extension/MIME type entry.

*/

CFileExtensionMIMEType* CFileExtensionMIMEType::NewL(const TDesC8& aExtn, const TDesC8& aMIMEType, const TDesC& aDisplayName, TUid aImageType, TUid aImageSubType, TUid aImplementationUid)

	{

	CFileExtensionMIMEType* self = CFileExtensionMIMEType::NewLC(aExtn, aMIMEType, aDisplayName, aImageType, aImageSubType, aImplementationUid);

	CleanupStack::Pop();

	return self;

	}

/**

Constructs a new file extension/MIME type entry. The new object is left on the clean-up stack.

A leave occurs if there is insufficient memory available.

@param  aExtn

        The file extension.

@param  aMIMEType 

        The associated MIME type.

@param  aDisplayName The display name of the implementation 

@param  aImageType The plugin decoder/encoder type UID. 

@param  aImageSubType The plugin decoder/encoder sub-type UID. 

@param  aImplementationUid The unique ID of the implementation. 

@return A pointer to the new file extension/MIME type entry.

*/

EXPORT_C CFileExtensionMIMEType* CFileExtensionMIMEType::NewLC(const TDesC8& aExtn, const TDesC8& aMIMEType, const TDesC& aDisplayName, TUid aImageType, TUid aImageSubType, TUid aImplementationUid)

	{

	CFileExtensionMIMEType* self = new(ELeave) CFileExtensionMIMEType;

	CleanupStack::PushL(self);

	self->ConstructL(aExtn, aMIMEType, aDisplayName, aImageType, aImageSubType, aImplementationUid);

	return self;

	}

/**

Default constructor. 

*/

CFileExtensionMIMEType::CFileExtensionMIMEType()

	{

	}

/**

Second phase constructor. 

@param aExtn The file extension 

@param aMIMEType The associated MIME type. 

@param aDisplayName The display name of the implementation 

@param aImageType The plugin decoder/encoder type UID. 

@param aImageSubType The plugin decoder/encoder sub-type UID. 

@param aImplementationUid The unique ID of the implementation. 

*/

void CFileExtensionMIMEType::ConstructL(const TDesC8& aExtn, const TDesC8& aMIMEType, const TDesC& aDisplayName, TUid aImageType, TUid aImageSubType, TUid aImplementationUid)

	{

	iFileExtension = HBufC::NewL(aExtn.Length());

	iFileExtension->Des().Copy(aExtn); // Create a 16 bit copy of the 8 bit original

	ASSERT(iFileExtension->Length() == aExtn.Length());

	iMIMEType = aMIMEType.AllocL();

	ASSERT(iMIMEType->Length() == aMIMEType.Length());

	iDisplayName = aDisplayName.AllocL();

	iImageTypeUid = aImageType;

	iImageSubTypeUid = aImageSubType;

	iImplementationUid = aImplementationUid;

	}

/**

Destructor.

Frees all resources owned by the object prior to its destruction.

*/

EXPORT_C CFileExtensionMIMEType::~CFileExtensionMIMEType()

	{

	delete iFileExtension;

	delete iMIMEType;

	delete iDisplayName;

	}

/**

Returns the image file extension info.

@return A reference to the descriptor containing the file extension.

*/

EXPORT_C const TDesC& CFileExtensionMIMEType::FileExtension() const

	{

	return *iFileExtension;

	}

/**

Returns the image MIME type info.

@return A reference to the descriptor containing the MIME type.

*/

EXPORT_C const TDesC8& CFileExtensionMIMEType::MIMEType() const

	{

	return *iMIMEType;

	}

/**

Returns the human-readable plugin description.

@return A reference to the display descriptor.

*/

EXPORT_C const TDesC& CFileExtensionMIMEType::DisplayName() const

	{

	return *iDisplayName;

	}

/**

Returns the image type associated with the plugin.

@return The image type associated with the plugin

*/

EXPORT_C TUid CFileExtensionMIMEType::ImageType() const

	{

	return iImageTypeUid;

	}

/**

Returns the image sub-type associated with the plugin.

@return The image sub-type associated with the plugin.

*/

EXPORT_C TUid CFileExtensionMIMEType::ImageSubType() const

	{

	return iImageSubTypeUid;

	}

/**

Returns the implementation UID of the plugin.

@return	The implementation UID of the plugin.

*/

EXPORT_C TUid CFileExtensionMIMEType::ImplementationUid() const

	{

	return iImplementationUid;

	}

//

// CImplementationInformationType

//

/**

Constructs a new implementation information object.

@return A pointer to the new implementation information object.

*/

CImplementationInformationType* CImplementationInformationType::NewL()

	{

	CImplementationInformationType* self = CImplementationInformationType::NewLC();

	CleanupStack::Pop();

	return self;

	}

// CImplementationInformationType transfer ownership of iDisplyName, iDataType and iOpaqueData

/**

Sets the contents of the CImplementationInformationType object.

Use this variant of SetDataL() if the plugin is installed on a drive other than the default, which is zero.

@param  aImplementationUid

        The unique ID of the implementation.

@param  aVersion

        The version number of the implementation.

@param  aDisplayName

        The display name of the implementation.

@param  aDataType

        The data type supported by the implementation.

@param  aOpaqueData

        Additional data for this implementation. This data is not used by the ECom framework.

@param  aDrive

        The drive on which the plugin is installed.

*/

void CImplementationInformationType::SetDataL(TUid aImplementationUid, TInt aVersion, const TDesC& aDisplayName, const TDesC8& aDataType, const TDesC8& aOpaqueData, TDriveUnit aDrive)

	{

	iImplementationUid = aImplementationUid;

	iVersion = aVersion;

	delete iDisplayName; iDisplayName = NULL;

	iDisplayName = aDisplayName.AllocL();

	delete iDataType; iDataType = NULL;

	iDataType = aDataType.AllocL();

	delete iOpaqueData; iOpaqueData = NULL;

	iOpaqueData = aOpaqueData.AllocL();

	iDrive = aDrive;

	}

/**

Default constructor.

This member is internal and not intended for use.

*/

CImplementationInformationType::CImplementationInformationType()

	{

	}

/**

Constructs a new implementation information object. The new object is left on the clean-up stack.

@return A pointer to the new implementation information object.

*/

CImplementationInformationType* CImplementationInformationType::NewLC()

	{

	CImplementationInformationType* self = new(ELeave) CImplementationInformationType;

	CleanupStack::PushL(self);

	return self;

	}

/**

Destructor.

Frees all resources owned by the object prior to its destruction.

*/

EXPORT_C CImplementationInformationType::~CImplementationInformationType()

	{

	delete iDisplayName;

	delete iDataType;

	delete iOpaqueData;

	}

/**

Returns the implementation UID.

@return The implementation UID as a TUid object.

*/

EXPORT_C TUid CImplementationInformationType::ImplementationUid() const

	{

	return iImplementationUid;

	}

/**

Returns the version number of the implementation.

@return The version number of the implementation.

*/

EXPORT_C TInt CImplementationInformationType::Version() const

	{

	return iVersion;

	}

/**

Returns the display name of the implementation.

@return A reference to the display name of the implementation.

*/

EXPORT_C const TDesC& CImplementationInformationType::DisplayName() const

	{

	return *iDisplayName;

	}

/**

Returns the data type supported by the implementation.

@return A reference to the descriptor containing the data type.

*/

EXPORT_C const TDesC8& CImplementationInformationType::DataType() const

	{

	return *iDataType;

	}

/**

Returns the opaque binary data for the implementation.

@return A reference to the descriptor containing the data.

*/

EXPORT_C const TDesC8& CImplementationInformationType::OpaqueData() const

	{

	return *iOpaqueData;

	}

/**

Returns the drive location information for the implementation.

@return The drive location information as a TDriveUnit object.

*/

EXPORT_C TDriveUnit CImplementationInformationType::Drive()

	{

	return iDrive;

	}

/**

Function to sort an array of CFileExtensionMIMEType in ascending

order of file extesion and MIME type.

@param  aItem1

        The first element.

@param  aItem2

        The second element.

@return	An indication of the element swapping order.

*/

TInt ImageEnDecoderUtils::SortAsending(const CFileExtensionMIMEType& aItem1, const CFileExtensionMIMEType& aItem2)

	{

	TInt result = aItem1.FileExtension().Compare(aItem2.FileExtension());

	if(result==0)

		result = aItem1.MIMEType().Compare(aItem2.MIMEType());

	return result;

	}

// Used by the 4 decoder and encoder functions that return arrays of Uids and plugin descriptions

void ImageEnDecoderUtils::DoGetImageTypesL(TUid aInterfaceUid, RImageTypeDescriptionArray& aImageTypeArray, TUid aBaseType)

	{

	RImplInfoPtrArray pluginArray; // Array to return matching plugins in

	CleanupResetAndDestroyPushL(pluginArray);

	CCustomMatchData* customMatchData = CCustomMatchData::NewLC();

	TEComResolverParams resolverParams; // Parameters on which to match

	customMatchData->SetMatchType(EListImageTypes);

	customMatchData->SetBaseType(aBaseType);

	customMatchData->SetSubType(KNullUid);

	customMatchData->SetImplementationType(KNullUid);

	HBufC8* package  = customMatchData->NewPackLC();

	TPtr8 packageDes = package->Des();

	resolverParams.SetDataType(packageDes);

	REComSession::ListImplementationsL(aInterfaceUid, resolverParams, KImageConvertResolverUid, pluginArray);

	if (pluginArray.Count() == 0)

		User::Leave(KErrNotFound);

	CleanupStack::PopAndDestroy(2); // package, customMatchData

	// Transfer data to our array

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

		{

		COpaqueDataParse* parser = NULL;

		TRAPD(error, parser = COpaqueDataParse::NewL(pluginArray[index]->OpaqueData()));

		if (error!=KErrNone)

			{

			if (error==KErrNotSupported)

				{

				// means that the resource entry was not valid

				continue;

				}

			else

				User::Leave(error);

			}

		CleanupStack::PushL(parser);

		CImageTypeDescription* imageTypeDescription = CImageTypeDescription::NewLC(pluginArray[index]->DisplayName(), parser->ImageTypeUid(), parser->ImageSubTypeUid());

		TBool mustAppend = ETrue;

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

			{

			if(	aImageTypeArray[i]->ImageType().iUid == imageTypeDescription->ImageType().iUid &&

				aImageTypeArray[i]->SubType().iUid == imageTypeDescription->SubType().iUid &&

				(aImageTypeArray[i]->Description().Compare(imageTypeDescription->Description())) == 0)

				{

				// If here - image type implementation with same description is already in array.

				mustAppend = EFalse;

				CleanupStack::PopAndDestroy(imageTypeDescription); 

				break;

				}

			}

		if(mustAppend)

			{

			//A new image type implementation, add it to array.

			User::LeaveIfError(aImageTypeArray.Append(imageTypeDescription));		

			CleanupStack::Pop(imageTypeDescription); 

			}