// Copyright (c) 2003-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 <e32std.h>

#include <utf.h>

#include <charconv.h>

#include <xml/plugins/charsetconverter.h>

#include <xml/xmlframeworkerrors.h>

using namespace Xml;

/**

The maximum number of bytes used for conversion at any time.

This is also used to size the necessary buffers used in the conversions.

@internalTechnology

*/

const TInt KMaxReadableBytes = 512;

LOCAL_C void DestroyHBufC16(TAny* aHBufC)

/**

This method is used when pointer reallocation is needed and the pointer needs to be 

cleaned via the cleanup stack.

@param				aHBufC the wide buffer.

@internalTechnology

*/

	{

	delete *static_cast<HBufC**>(aHBufC);

	}

LOCAL_C void DestroyHBufC8(TAny* aHBufC)

/**

This method is used when pointer reallocation is needed and the pointer needs to be 

cleaned via the cleanup stack.

@param				aHBufC the narrow buffer.

@internalTechnology

*/

	{

	delete *static_cast<HBufC8**>(aHBufC);

	}

CCharSetConverter::CCharSetConverter()

/**

Default Constructor

*/

	{

	// do nothing;

	}

/**

This method creates an instance of this class.

The framework is responsible for creating this object.

@leave ... One of the system wide error codes e.g. KErrNoMemory

@return	The new'ed object.

@internalTechnology

*/

CCharSetConverter* CCharSetConverter::NewL()

	{

	CCharSetConverter* self = new(ELeave) CCharSetConverter();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return(self);

	}

void CCharSetConverter::ConstructL()

/**

This method provides some construction of this object.

*/

	{

	iCnvCharacterSetConverter = CCnvCharacterSetConverter::NewL();

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

	iConversionBuffer = User::Heap().AllocL(KMaxReadableBytes);

	iConversionBufferSize = KMaxReadableBytes;

	}

CCharSetConverter::~CCharSetConverter()

/**

Destructor.

The framework is responsible for destroying this object.

@post				This object is properly destroyed.

*/

	{

	iFs.Close();

	delete iCnvCharacterSetConverter;

	delete iConversionBuffer;

	}

EXPORT_C void CCharSetConverter::PrepareCharConvL(TUint& aCharSetUid, const TDesC8& aEncoding)

/**

This method prepares CharConv to encode from the standard name.

@post				CharConv has been prepared.

@leave				KErrXmlUnsupportedCharacterSet - Charset not supported.

@leave				KErrXmlUnavailableCharacterSet - Charset not available

@param				aCharSetUid On return, contains the character set identifier 

					of the encoding.

@param				aEncoding the encoding to prepare for.

*/

	{

	// Get the charset uid

	if ((aCharSetUid = 

		iCnvCharacterSetConverter->ConvertStandardNameOfCharacterSetToIdentifierL(aEncoding, iFs)) == 0)

		{

		User::Leave(KErrXmlUnsupportedCharacterSet);

		}

	// Prepare charconv to use this charset

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aCharSetUid, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable )

		{

		User::Leave(KErrXmlUnavailableCharacterSet); // Unavailable

		}

	}

EXPORT_C void CCharSetConverter::PrepareCharConvL(TUint& aCharSetUid, TInt aMibEnum)

/**

This method prepares CharConv to encode from the mib enum.

@post				CharConv has been prepared.

@leave				KErrXmlUnsupportedCharacterSet - Charset not supported.

@leave				KErrXmlUnavailableCharacterSet - Charset not available

@param				aCharSetUid On return, contains the character set identifier 

					of the encoding.

@param				aMibEnum The IANA specified mib enum for this encoding

@see				http://www.iana.org/assignments/character-sets

*/

	{

	// Get the charset uid

	if ((aCharSetUid = 

		iCnvCharacterSetConverter->ConvertMibEnumOfCharacterSetToIdentifierL(aMibEnum, iFs)) == 0)

		{

		User::Leave(KErrXmlUnsupportedCharacterSet);  // May want to try something else?

		}

	// Prepare charconv to use this charset

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aCharSetUid, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable )

		{

		User::Leave(KErrXmlUnavailableCharacterSet); // Unavailable

		}

	}

EXPORT_C TInt CCharSetConverter::ConvertToUnicodeL(TUint32 aSrcCharset, const TDesC8& aInputBuffer, 

														 HBufC16*& aUnicodeConversion)

/**

This method converts the given bytes to unicode.

If this function leaves, memory is cleaned up.

This overload allocates memory for the output itself.

@return				KErrNone if the conversion was succesfull

					or one of the error values defined in TError.

@leave				KErrXmlUnavailableCharacterSet - CharSet not available.

@param				aSrcCharset The character set encoding to convert from.

@param				aInputBuffer The characters to be converted.

@param				aUnicodeConversion On return, contains the unicode conversion.

*/

	{	

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aSrcCharset, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable)

		{

		User::Leave(KErrXmlUnavailableCharacterSet);

		}

	TInt maxLength = KMaxReadableBytes;	

	aUnicodeConversion = HBufC16::NewL(maxLength);	

	CleanupStack::PushL(TCleanupItem(DestroyHBufC16, &aUnicodeConversion));//push buffer's address

	TInt state = CCnvCharacterSetConverter::KStateDefault;

	TPtr16 remainingOutput(aUnicodeConversion->Des());

	TInt unconverted = iCnvCharacterSetConverter->ConvertToUnicode(remainingOutput, aInputBuffer, state);	

	// While there is still more data to convert

	while (0 < unconverted)	

		{

		// Resize the buffer to hold more data

		maxLength += KMaxReadableBytes;

		aUnicodeConversion = aUnicodeConversion->ReAllocL(maxLength);

		// Segment the writable area

		TInt outputLength = aUnicodeConversion->Length();

		TPtr16 remainingOutput1(&(aUnicodeConversion->Des())[0] + outputLength, 0, maxLength - outputLength);

		remainingOutput.Set(remainingOutput1);

		// Convert the data

		unconverted = iCnvCharacterSetConverter->ConvertToUnicode(remainingOutput, aInputBuffer.Right(unconverted), state);

		aUnicodeConversion->Des().SetLength(outputLength + remainingOutput.Length());

		}

	// Reallocate to a minimally-sized buffer	

	if (unconverted == 0)

		{

		aUnicodeConversion = aUnicodeConversion->ReAllocL(aUnicodeConversion->Length());

		}

	CleanupStack::Pop(&aUnicodeConversion);//destroy the object pointed by the buffer wherever it is since we have got hold of the pointer (buffer)'s address

	return unconverted;  // return error value if there is one.

	}

EXPORT_C TInt CCharSetConverter::ConvertToUnicodeL(TUint32 aSrcCharset, 

												   const TDesC8& aInput,

												   TPtr16& aOutput)

/**

This method converts the given bytes to unicode.

If this function leaves, memory is cleaned up.

This overload stores the conversion output in memory already allocated, for the sole use

of the TPtr versions of overloaded ConvertToUnicodeL and ConvertFromUnicodeL functions. You must make sure you

have finished with the output from a previous call to either (TPtr overload of) ConvertToUnicodeL

or ConvertFromUnicodeL before calling either again, as the previous output will be overwritten with

the new output.

This version is more efficient than the HBufC alternative and so should be used whenever possible.

@return				KErrNone if the conversion was succesfull

					or one of the error values defined in TError.

@leave				KErrXmlUnavailableCharacterSet - CharSet not available.

@param				aSrcCharset The character set encoding to convert from.

@param				aInput The characters to be converted.

@param				aOutput On return, contains the unicode conversion.

*/

	{	

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aSrcCharset, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable)

		{

		User::Leave(KErrXmlUnavailableCharacterSet);

		}

	TInt state = CCnvCharacterSetConverter::KStateDefault;

	// Set up output descriptor reference: "Payload" is iConversionBuffer (a TAny *), it's initial

	// length is zero (because it's empty) and it's initial maximum length is the maximum number of

	// unicode characters which will fit into the current size of iConversion buffer 	

	aOutput.Set((TUint16*)iConversionBuffer, 0, iConversionBufferSize/sizeof(TUint16));

	// Convert the data, returning the amount of characters that are unconverted, due to the output buffer being full

	TInt unconverted = iCnvCharacterSetConverter->ConvertToUnicode(aOutput, aInput, state);	

	// While there is still more data to convert

	while (0 < unconverted)	

		{

		TInt outputLength = aOutput.Length();

		// Resize the buffer to hold more data

		iConversionBufferSize += KMaxReadableBytes;

		iConversionBuffer = User::Heap().ReAllocL(iConversionBuffer,iConversionBufferSize);

		if (iConversionBuffer == NULL) 	

			User::Leave(KErrNoMemory);

		// Reconstruct the output descriptor to point to the new buffer, setting current

		// length (the number of characters we've converted so far) and maximum length

		// (the number of unicode characters which will fit into the newly extended 

		// iConversionBuffer) appropriately. 

		aOutput.Set((TUint16*)iConversionBuffer, outputLength, iConversionBufferSize/sizeof(TUint16));		

		// Construct a modifiable pointer descriptor pointing to the the writable area of

		// iConversionBuffer

		TPtr16 remainingOutput(((TUint16*)iConversionBuffer)+outputLength, 0, aOutput.MaxLength() - outputLength);

		// Try to convert another chunk of data

		unconverted = iCnvCharacterSetConverter->ConvertToUnicode(remainingOutput, aInput.Right(unconverted), state);

		// Update the length of the output buffer to include the data we just converted.

		aOutput.SetLength(remainingOutput.Length()+outputLength);

		}

	return unconverted;  // return error value if there is one.

	}

EXPORT_C TInt CCharSetConverter::ConvertFromUnicodeL(const TDesC16& aUnicodeConversion, 

														   TUint32 aDestCharset, HBufC8*& aOutputBuffer)

/**

This method converts the given unicode to the specified encoding.

If this function leaves, memory is cleaned up.

This overload allocates memory for the output itself.

@return				KErrNone if the conversion was succesfull

					or one of the error values defined in TError.

@leave				KErrXmlUnavailableCharacterSet - Charset not available.

@param				aUnicodeConversion The unicode to convert.

@param				aDestCharset The character set encoding to convert to.

@param				aOutputBuffer On return, contains the specified conversion.

*/

	{

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aDestCharset, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable)

		{

		User::Leave(KErrXmlUnavailableCharacterSet);

		}

	TInt maxLength = KMaxReadableBytes;	

	aOutputBuffer = HBufC8::NewL(maxLength);	

	CleanupStack::PushL(TCleanupItem(DestroyHBufC8, &aOutputBuffer));//push buffer's address

	TPtr8 remainingOutput(aOutputBuffer->Des());

	TInt unconverted = iCnvCharacterSetConverter->ConvertFromUnicode(remainingOutput, aUnicodeConversion);	

	// While there is still more data to convert

	while (0 < unconverted)	

		{

		// Resize the buffer to hold more data

		maxLength += KMaxReadableBytes;

		aOutputBuffer = aOutputBuffer->ReAllocL(maxLength);

		// Segment the writable area

		TInt outputLength = aOutputBuffer->Length();

		TPtr8 remainingOutput1(&(aOutputBuffer->Des())[0] + outputLength, 0, maxLength - outputLength);

		remainingOutput.Set(remainingOutput1);

		// Convert the data

		unconverted = iCnvCharacterSetConverter->ConvertFromUnicode(remainingOutput, aUnicodeConversion.Right(unconverted));

		aOutputBuffer->Des().SetLength(outputLength + remainingOutput.Length());

		}

	// Reallocate to a minimally-sized buffer	

	if (unconverted == 0)

		{

		aOutputBuffer = aOutputBuffer->ReAllocL(aOutputBuffer->Length());

		}

	CleanupStack::Pop(&aOutputBuffer);//destroy the object pointed by the buffer wherever it is since we have got hold of the pointer (buffer)'s address

	return unconverted;  // return error value if there is one.

	}

EXPORT_C TInt CCharSetConverter::ConvertFromUnicodeL(const TDesC16& aInput,

													 TUint32 aDestCharset,

													 TPtr8& aOutput)

/**

This method converts the given unicode to the specified encoding. 

If this function leaves, memory is cleaned up.

This overload stores the conversion output in memory already allocated, for the sole use

of the TPtr versions of overloaded ConvertToUnicodeL and ConvertFromUnicodeL functions. You must make sure you

have finished with the output from a previous call to either (TPtr overload of) ConvertToUnicodeL

or ConvertFromUnicodeL before calling either again, as the previous output will be overwritten with

the new output.

This version is more efficient than the HBufC alternative and so should be used whenever possible.

@return				KErrNone if the conversion was succesfull

					or one of the error values defined in TError.

@leave				KErrXmlUnavailableCharacterSet - Charset not available.

@param				aInput The unicode to convert.

@param				aDestCharset The character set encoding to convert to.

@param				aOutput The characters after conversion.

*/

	{

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aDestCharset, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable)

		{

		User::Leave(KErrXmlUnavailableCharacterSet);

		}

	// Set up output descriptor reference: "Payload" is iConversionBuffer (a TAny *), it's initial

	// length is zero (because it's empty).	

	aOutput.Set((TUint8*)iConversionBuffer, 0, iConversionBufferSize);	

	// Convert the data, returning the amount of characters that are unconverted, due to the output buffer being full

	TInt unconverted = iCnvCharacterSetConverter->ConvertFromUnicode(aOutput, aInput);	

	// While there is still more data to convert

	while (0 < unconverted)	

		{

		TInt outputLength = aOutput.Length();

		// Resize the buffer to hold the remaining data

		iConversionBufferSize += KMaxReadableBytes;

		iConversionBuffer = User::Heap().ReAllocL(iConversionBuffer,iConversionBufferSize);

		if (iConversionBuffer == NULL) 	

			User::Leave(KErrNoMemory);

		aOutput.Set((TUint8*)iConversionBuffer,iConversionBufferSize,iConversionBufferSize);

		// Construct a modifiable pointer descriptor pointing to the the writable area of

		// iConversionBuffer

		TPtr8 remainingOutput(((TUint8*)iConversionBuffer) + outputLength, 0, iConversionBufferSize - outputLength);

		// Try to convert another chunk of data

		unconverted = iCnvCharacterSetConverter->ConvertFromUnicode(remainingOutput, aInput.Right(unconverted));

		// Update the length of the output buffer to include the data we just converted.

		aOutput.SetLength(remainingOutput.Length()+outputLength);

		}

	return unconverted;  // return error value if there is one.

	}

EXPORT_C void CCharSetConverter::PrepareToConvertToOrFromL(TUint32 aCharSetUid)

/**

This method is a helper function that prepares CharConv for a conversion.

@see				CCnvCharacterSetConverter::PrepareToConvertToOrFromL

@post				CharConv is ready for the conversion or not.

@leave				KErrXmlUnavailableCharacterSet - Charset not available.

@param				aCharSetUid The character set encoding to convert to.

*/

	{

	if (iCnvCharacterSetConverter->PrepareToConvertToOrFromL(aCharSetUid, iFs) == 

			CCnvCharacterSetConverter::ENotAvailable )

		{

		User::Leave(KErrXmlUnavailableCharacterSet);

		}

	}

EXPORT_C void CCharSetConverter::ConvertCharacterSetIdentifierToStandardNameL(TUint32 aCharSetUid, 

																			  HBufC8*& aCharSet)

/**

This method is a helper function that obtains a standand character

encoding name from a character set identifer.

@see				CCnvCharacterSetConverter::ConvertCharacterSetIdentifierToStandardNameL

@leave				KErrXmlUnsupportedCharacterSet If the character set is not known.

@param				aCharSetUid The character set to obtain the name for.

@param				aCharSet On return holds the Internet-standard name

					or MIME name of the character set.

					The name is encoded in 8 bit ASCII. 

*/

	{

	if ((aCharSet = 

		iCnvCharacterSetConverter->

			ConvertCharacterSetIdentifierToStandardNameL(aCharSetUid, iFs)) == NULL)

		{

		User::Leave(KErrXmlUnsupportedCharacterSet);

		}

	}

EXPORT_C TInt CCharSetConverter::ConvertUcs4CharactersToEncodingL(TUint32* aUcs4Src, 

																  TInt aUcs4Count, 

																  TUint32 aDestCharset,

																  HBufC8*& aConversion)

/**

This method converts ucs-4 characters to the desired non-modal encoding.

aConversion should be NULL on calling of this function.

If this function leaves, memory is cleaned up.

There is no TPtr overload of this method, as currently it is only called a few times and so would not 

produce any noticable benefits.

@return				CCharSetConverter::ConvertFromUnicodeL.

@leave				KErrXmlBadCharacterConversion

@param				aUcs4Src list of ucs-4 characters.

@param				aUcs4Count number of ucs4 characters.

@param				aDestCharset the desired encoding.

@param				aConversion On return, points to the converted encoding.

*/

	{

	// convert ucs-4 to ucs-2

	// Find the length of the output

	TText16 buf[2];

	TInt length = 0;

	TUint32* src = NULL;

	for (src = aUcs4Src; src != (aUcs4Src + aUcs4Count); ++src)

		{

		// Convert a single character into the buffer, discard the result

		// but increase the length by the number of UTF16 codes output.

		length += Utf32ToUtf16(buf, *src) - buf;

		}

	HBufC16* utf16Out = HBufC16::NewL(length);

	CleanupStack::PushL(utf16Out);