/*
* Copyright (c) 2009 Sony Ericsson Mobile Communications AB
* 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:
* Sony Ericsson Mobile Communications AB - initial contribution.
* Nokia Corporation - additional changes.
* 
* Contributors:
* 
* Description:
* Implements the Enhanced SMS Animation Information Element.
*
*/


/**
 *  @file
 *  
 *  Implements  EMSInformationElement class
 */

#include <emsinformationelement.h>
#include <emsformatie.h>
#include <emssoundie.h>
#include <emsanimationie.h>
#include <emspictureie.h>
#include <emsuserpromptie.h>
#include <emsobjectdistributionie.h>


EXPORT_C void CEmsInformationElement::SetStartPosition(TUint aValue)
/**
 *  @capability None
 */
	{
	iStartPosition = aValue;
	}

EXPORT_C TUint CEmsInformationElement::StartPosition() const
/**
 *  @capability None
 */
	{
	return iStartPosition;
	}

EXPORT_C TInt CEmsInformationElement::Length() const
/**
 *  @capability None
 */
	{
	// The length includes the IE header (IEID, IEL) and the
	// start position, if applicable, plus the encoded body length
	TInt len = 2 + iEncodedBodyLength;
	if (iStartPosEncoded)
		{
		++len;
		}

	return len;
	}


/**
 *  Encodes the EmsInformationElement into a CSmsInformationElement
 *  
 *  @param aSmsIe SMS information element to encode into
 */
EXPORT_C void CEmsInformationElement::EncodeInformationElementL()
/**
 *  @capability None
 */
	{
	TInt ieLength = iEncodedBodyLength;

	// if start position is to be encoded, then increment this length
	if (iStartPosEncoded)
		{
		++ieLength;
		}

	// Create a new body for the IE
	NewDataL(ieLength);

	// Get the raw data to be encoded
	TPtr8 ptr(Data());
	ptr.SetLength(0);

	// Encode start position if required
	if (iStartPosEncoded)
		{
		ptr.Append(static_cast<TUint8>(iStartPosition));
		}

	// Call the specific encode body function - false indicates NOT
	// for serialisation
	EncodeBodyL(ptr, EFalse);
	}

CEmsInformationElement* CEmsInformationElement::DecodeInformationElementL(const CSmsInformationElement& aSmsIe)
	{
	// Firstly, create the element given the ID
	CEmsInformationElement* elem = CEmsFactory::CreateIeL(aSmsIe.Identifier());

	if (!elem)
		{
		User::Leave(KErrCorrupt);
		}

	CleanupStack::PushL(elem);

	// now decode the rest of the element
	const TUint8* ptr;
	const TDesC8& des = aSmsIe.Data();
	TInt length = des.Length();

	if (length <= 0)
		User::Leave(KErrCorrupt);

	// If the start position is encoded, then decode it, and add back
	// in the start position offset
	if (elem->iStartPosEncoded)
		{
		elem->iStartPosition = des[0];

		// set the pointer to point to the first element, and
		// reduce the length by 1;
		ptr = &des[1];
		--length;
		}

	else
		{
		// otherwise, set it to the first element
		ptr = &des[0];
		}

	// set the encoded body length to be what's left over
	elem->iEncodedBodyLength = length;

	// Now call the specific decode body function.
	elem->DecodeBodyL(TPtrC8(ptr, length), EFalse);

	CleanupStack::Pop(elem);
	return elem;
	}

void CEmsInformationElement::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt16L(TInt16(iIdentifier));
	aStream.WriteUint16L(iStartPosition);
	aStream.WriteInt16L(iEncodedBodyLength);

	// Now create a buffer to hold the serialised body, and encode
	HBufC8* buf = HBufC8::NewLC(SerialisedBodyLength());
	EncodeBodyL(buf->Des(), ETrue);
	aStream << *buf;
	CleanupStack::PopAndDestroy(buf);
	}

CEmsInformationElement* CEmsInformationElement::InternalizeL(RReadStream& aStream)
	{
	// Get the id and create the appropriate
	TSmsId id;
	id = TSmsId(aStream.ReadInt16L());
	CEmsInformationElement* elem = CEmsFactory::CreateIeL(id);

	if (!elem)
		{
		User::Leave(KErrCorrupt);
		}

	CleanupStack::PushL(elem);

	// now stream into the new element
	elem->iStartPosition = aStream.ReadUint16L();
	elem->iEncodedBodyLength = aStream.ReadInt16L();

	// Create the buffer to hold the body data
	HBufC8* buf = HBufC8::NewLC(aStream, elem->SerialisedBodyLength());
	elem->DecodeBodyL(buf->Des(), ETrue);

	CleanupStack::PopAndDestroy(buf);
	CleanupStack::Pop(elem);

	return elem;
	}

void CEmsInformationElement::CopyL(const CEmsInformationElement& aSrc)
	{
	iIdentifier = aSrc.iIdentifier;
	iStartPosition = aSrc.iStartPosition;
	iEncodedBodyLength = aSrc.iEncodedBodyLength;
	}

TInt CEmsInformationElement::SerialisedBodyLength() const
	{
	// default behaviour for this is to return the encoded body length.
	// This will be overriden by elements which differ (ie FormatIE)
	return iEncodedBodyLength;
	}

/**
 *  Internalize all Ems Objects from a given stream. This is the flipside of the factorys
 *  externalise method.
 *  
 *  @param aStream stream to restore from.
 *  @return CEmsInformationElement* newly created EMS object.
 */

/**
 *  Creates an information element from the data given
 *  
 *  @param aId EMS object id.
 *  @param aData Information Elements raw data.
 *  @return CEmsInformationElement* newly created EMS object.
 */
CEmsInformationElement* CEmsFactory::CreateIeL(TSmsId aSmsId)
	{
	CEmsInformationElement* pObj=NULL;
	switch (aSmsId)
		{
		case CSmsInformationElement::ESmsEnhancedTextFormatting:
			pObj = CEmsFormatIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedPredefinedSound:
			pObj = CEmsPreDefSoundIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedUserDefinedSound:
			pObj = CEmsSoundIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedPredefinedAnimation:
			pObj = CEmsPreDefAnimationIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedLargeAnimation:
		case CSmsInformationElement::ESmsEnhancedSmallAnimation:
			pObj = CEmsAnimationIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedLargePicture:
		case CSmsInformationElement::ESmsEnhancedSmallPicture:
		case CSmsInformationElement::ESmsEnhancedVariablePicture:
			pObj = CEmsPictureIE::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedUserPromptIndicator:
			pObj = CEmsUserPrompt::NewL();
			break;
		case CSmsInformationElement::ESmsEnhancedODI:
			pObj = CEmsObjectDistribution::NewL();
			break;
		default:
			break;
		}
	if(pObj)
		{
		// set the id of the newly created EMS information element
		pObj->iIdentifier = aSmsId;
		}
	return pObj;
	}

/**
 *  Externalises all the objects in a given object array. Adds extra information into externalised data
 *  so that objects can be readback generically (done this was as All streams do not support seek operatoions).
 *  This is the flipside of the Factorys internalise method.
 *  
 *  @param aObjectStore Array of objects to externalize.
 *  @param aStream stream to externalize object to.
 */
void CEmsFactory::ExternalizeL(RPointerArray<CEmsInformationElement>& aObjectStore, RWriteStream& aStream)
	{
	TUint count= aObjectStore.Count();
	aStream.WriteUint32L(count);
	for (TUint i=0; i< count; i++)
		{
		aObjectStore[i]->ExternalizeL(aStream);
		}
	}

void CEmsFactory::InternalizeL(RPointerArray<CEmsInformationElement>& aObjectStore, RReadStream& aStream)
	{
	// Retain store compat. with other Hur. 7 messaging stores.
	TInt count=0;
	TRAPD(test, count = aStream.ReadUint32L());
	if(test == KErrEof)
		test=KErrNone;
	User::LeaveIfError(test);

	CEmsInformationElement* ie = NULL;

	while(count--)
		{
		TRAPD(ret, (ie = CEmsInformationElement::InternalizeL(aStream)));
		if(ret==KErrNone)
			{
			CleanupStack::PushL(ie);
			User::LeaveIfError(aObjectStore.Append(ie));
			CleanupStack::Pop(ie);
			}
		else if(ret!=KErrCorrupt)
			User::Leave(ret);
		}
	}

CEmsInformationElement* CEmsFactory::CreateReceivedEmsIEL(const CSmsInformationElement& aIE,TInt aBaseAddr)
	{
	CEmsInformationElement* newIE =
		CEmsInformationElement::DecodeInformationElementL(aIE);

	newIE->iStartPosition += aBaseAddr;

	return newIE;
	}


TBool CEmsFactory::Supported(TSmsId aId)
	{
	TBool ret=ETrue;
	switch (aId)
		{
	case CSmsInformationElement::ESmsEnhancedTextFormatting:
	case CSmsInformationElement::ESmsEnhancedPredefinedSound:
	case CSmsInformationElement::ESmsEnhancedUserDefinedSound:
	case CSmsInformationElement::ESmsEnhancedPredefinedAnimation:
	case CSmsInformationElement::ESmsEnhancedLargeAnimation:
	case CSmsInformationElement::ESmsEnhancedSmallAnimation:
	case CSmsInformationElement::ESmsEnhancedLargePicture:
	case CSmsInformationElement::ESmsEnhancedSmallPicture:
	case CSmsInformationElement::ESmsEnhancedVariablePicture:
	case CSmsInformationElement::ESmsEnhancedUserPromptIndicator:
	case CSmsInformationElement::ESmsEnhancedODI:
		ret=ETrue;
		break;
	default:
		ret=EFalse;
		}
	return ret;
	}