// 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:

// Contains the implementation of the CSmsMessage class

// 

//

/**

 @file

*/

#include <gsmumsg.h>

#include "Gsmumain.h"

#include <gsmubuf.h>

#include <gsmuset.h>

#include <gsmusar.h>

#include "gsmumsgadditionalattributes.h"

#include <gsmuieoperations.h>

#include <gsmunonieoperations.h>

#include <e32uid.h>

#include <etelmm.h>

#include <emsinformationelement.h>

#include <emsformatie.h>

#include <emsuserpromptie.h>

#include <emsobjectdistributionie.h>

#include "smsstackutils.h"

/**

 *  Allocates and creates a CSmsMessage instance from a TGsmSms.

 *  

 *  The type of SMS-XXXX message to construct is defined by the first byte of

 *  the TGsmSms TPDU header.

 *  

 *  @param aFs Reference handle to the file system

 *  @param aGsmSms Reference to TGsmSms

 *  @param aBuffer The Unicode text for the message. The object takes ownership

 *  of aBuffer.

 *  @param aIsRPError Set to true if the message contains Reply Path Error. Default

 *  is false.

 *  @param aIsMobileTerminated Set to True if the message is Mobile Terminated.

 *  Default is false.

 *  @return New CSmsMessage object

 *  @capability None

 */

EXPORT_C CSmsMessage* CSmsMessage::NewL(RFs& aFs, const TGsmSms& aGsmSms,CSmsBufferBase* aBuffer, TBool aIsRPError,TBool aIsMobileTerminated)

	{

	CleanupStack::PushL(aBuffer);

	CSmsMessage* smsmessage=new(ELeave) CSmsMessage(aFs, aBuffer);

	CleanupStack::Pop();

	CleanupStack::PushL(smsmessage);

	smsmessage->ConstructL(aGsmSms, aIsRPError,aIsMobileTerminated);

	CleanupStack::Pop();

	return smsmessage;

	} // CSmsMessage::NewL

/**

 *  Allocates and creates a CSmsMessage, specifying the SMS-XXX message type with

 *  a CSmsPDU::TSmsPduType.

 *  

 *  @param aFs Reference handle to the file system

 *  @param aType The PDU type

 *  @param aBuffer The Unicode text for the message. The object takes ownership

 *  of aBuffer.

 *  @param aIsRPError Set to true if the message contains Reply Path Error. Default

 *  is false.

 *  @return New CSmsMessage object

 *  @capability None

 */

EXPORT_C CSmsMessage* CSmsMessage::NewL(RFs& aFs, CSmsPDU::TSmsPDUType aType,CSmsBufferBase* aBuffer,TBool aIsRPError)

	{

	CleanupStack::PushL(aBuffer);

	CSmsMessage* smsmessage=new(ELeave) CSmsMessage(aFs, aBuffer);

	CleanupStack::Pop();

	CleanupStack::PushL(smsmessage);

	smsmessage->ConstructL(aType,aIsRPError);

	CleanupStack::Pop();

	return smsmessage;

	} // CSmsMessage::NewL

/**

 *  Destructor, frees resources.

 *  @capability None

 */

EXPORT_C CSmsMessage::~CSmsMessage()

	{

	delete iSmsPDU;

	delete iBuffer;

	delete iCharacterSetConverter;

	if (iInformationElementArray)

		{

		iInformationElementArray->ResetAndDestroy();

		delete iInformationElementArray;

		}

	delete iAdditionalInfo;

	} // CSmsMessage::NewL

/**

 *  Internalises all object data except for the CSmsBufferBase.

 *  

 *  This is used when the buffer is stored elsewhere.

 *  

 *  @param aStream Stream to read from

 *  @capability None

 */

EXPORT_C void CSmsMessage::InternalizeWithoutBufferL(RReadStream& aStream)

	{

	InternalizeWithoutBufferAndVersionL(aStream);

	InternalizeVersionL(aStream);

	iAdditionalInfo->ResetAttributesL();

	if (iVersion > ESmsMessageV0)

        {

        iAdditionalInfo->InternalizeL(aStream, iVersion);

		}

	} // CSmsMessage::InternalizeWithoutBufferL

/**

 *  Externalises all object data except for the CSmsBufferBase.

 *  

 *  This is used when the buffer is stored elsewhere.

 *  

 *  @param aStream Stream to write to

 *  @capability None

 */

EXPORT_C void CSmsMessage::ExternalizeWithoutBufferL(RWriteStream& aStream) const

	{

	ExternalizeWithoutBufferAndVersionL(aStream);

	ExternalizeVersionL(aStream);

	if (iVersion > ESmsMessageV0)

		{

		iAdditionalInfo->ExternalizeL(aStream, iVersion);

		}

	} // CSmsMessage::ExternalizeWithoutBufferL

/**

 *  Internalises all object data.

 *  

 *  @param aStream Stream to read from

 *  @capability None

 */

EXPORT_C void CSmsMessage::InternalizeL(RReadStream& aStream)

	{

	InternalizeWithoutBufferAndVersionL(aStream);

	InternalizeBufferL(aStream);

	InternalizeVersionL(aStream);

	iAdditionalInfo->ResetAttributesL();

	if (iVersion > ESmsMessageV0)

		{

		iAdditionalInfo->InternalizeL(aStream, iVersion);

		}

	} // CSmsMessage::InternalizeL

/**

 *  Externalises all object data.

 *  

 *  @param aStream Stream to write to

 *  @capability None

 */

EXPORT_C void CSmsMessage::ExternalizeL(RWriteStream& aStream) const

	{

	ExternalizeWithoutBufferAndVersionL(aStream);

	ExternalizeBufferL(aStream);

	ExternalizeVersionL(aStream);

	if (iVersion > ESmsMessageV0)

		{

		iAdditionalInfo->ExternalizeL(aStream, iVersion);

		}

	} // CSmsMessage::ExternalizeL

/**

 *  Tests if the message contains text.

 *  

 *  @return True if the message contains text

 *  @capability None

 */

EXPORT_C TBool CSmsMessage::TextPresent() const

	{

	CSmsPDU::TSmsPDUType pdutype=SmsPDU().Type();

	return (pdutype==CSmsPDU::ESmsSubmit) ||

	       (pdutype==CSmsPDU::ESmsDeliver) ||

	     (((pdutype==CSmsPDU::ESmsSubmitReport) || (pdutype==CSmsPDU::ESmsDeliverReport) ||

	      ((pdutype==CSmsPDU::ESmsStatusReport) && ((CSmsStatusReport&) SmsPDU()).ParameterIndicatorPresent())) &&

	      SmsPDU().UserDataPresent());

	} // CSmsMessage::TextPresent

/**

 *  Gets the number of PDU's required to encode the complete message.

 *  

 *  @leave KErrOverflow Leaves if the number of required PDUs exceeds the maximum

 *  or the message cannot be encoded.

 *  @return Number of PDU's

 *  @capability None

 */

EXPORT_C TInt CSmsMessage::NumMessagePDUsL()

	{

	TInt nummessagepdus=1;

	if (IsDecoded())

		{

		if (TextPresent())

			{

			nummessagepdus=NumMessageEmsPDUsL();

			TInt maxnummessagepdus=SmsPDU().TextConcatenated()? 0xFF: 1;

 			if (nummessagepdus>maxnummessagepdus)

				{

 				User::Leave(KErrOverflow);

				}

			}

		}

	else if (TextPresent() && SmsPDU().TextConcatenated())

		{

		nummessagepdus=SmsPDU().NumConcatenatedMessagePDUs();

		}

	return nummessagepdus;

	} // CSmsMessage::NumMessagePDUsL

/**

 *  Gets the maximum message length possible with the current settings.

 *  

 *  If Text is compressed, this returns the maximum number of bytes available

 *  with text compressed.

 *  

 *  @return Maximum message length

 *  @capability None

 */

EXPORT_C TInt CSmsMessage::MaxMessageLength() const

	{

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));

	TInt maxmessagelength=SmsPDU().UserData().MaxBodyLengthInChars();

	if (SmsPDU().TextConcatenated())

		{

		maxmessagelength=maxmessagelength*0xFF;

		}

	return maxmessagelength;

	} // CSmsMessage::MaxMessageLength

/**

 *  

 *  @return The converted buffer length

 *  @note Use with care - Expensive operation

 */

TInt CSmsMessage::ConvertedBufferLengthL(const CSmsBufferBase& aBuffer)

    {

    // Ignore in code coverage - not used in SMS stack and not exported

    // but cannot be removed as impacts public header.

    BULLSEYE_OFF    

    TInt convertedBufferLength=0;

    CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(*iCharacterSetConverter,iFs,SmsPDU().Alphabet(),BinaryData());

    CSmsBufferSegmenter* segmenter=CSmsBufferSegmenter::NewLC(*converter,aBuffer);

    convertedBufferLength=segmenter->TotalConvertedLengthL(iAdditionalInfo->Alternative7bitEncoding());

    CleanupStack::PopAndDestroy(2, converter);

    return convertedBufferLength;

    BULLSEYE_RESTORE

    }

/**

 *  Gets the message length.

 *  

 *  In the case where the message is compressed, this function compresses the

 *  text and returns the number of bytes of the compressed buffer.

 *  

 *  The function calls ConvertedBufferLengthL(), and is therefore an expensive

 *  operation.

 *  

 *  @return Message length

 *  @capability None

 */

EXPORT_C TInt CSmsMessage::MessageLengthL()

	{

	TInt messagelength=0;

	if (!SmsPDU().TextCompressed())

		{

		messagelength=iBuffer->Length();

		if(SmsPDU().Alphabet() == TSmsDataCodingScheme::ESmsAlphabetUCS2)messagelength*=2 ;

		}

	else

		{

		User::Leave(KErrNotSupported);

		}

	return messagelength;

	} // CSmsMessage::MessageLengthL

EXPORT_C void CSmsMessage::GetEncodingInfoL(TInt& aPdus, TInt& aUnconvertedChars,

		                                    TInt& aDowngradedChars, TInt& aFreeUDUnitsInLastPDU)

	{

	aPdus                 = 1;

	aUnconvertedChars     = 0;

	aDowngradedChars      = 0;

	aFreeUDUnitsInLastPDU = 0;

	if (TextPresent())

		{

		if (IsDecoded())

			{

			//

			// Clear the concatenated flag, EncodeBufferL() will add it if needed.

			//

			SmsPDU().SetTextConcatenatedL(EFalse, EFalse);

			//

			// Attempt to encode to a single PDU, and if that fails then attempt to

			// encode to a set of PDUs.

			//

			CArrayFixFlat<TGsmSms>*  tmpArray = new (ELeave) CArrayFixFlat<TGsmSms>(8);

			CleanupStack::PushL(tmpArray);

			//

			// Encode the message...

			//

			if (!EncodeIntoSinglePDUL(*tmpArray, aUnconvertedChars,

                                      aDowngradedChars, aFreeUDUnitsInLastPDU))

				{

				EncodeBufferL(*tmpArray, 0, *iBuffer, aUnconvertedChars,

						      aDowngradedChars, aFreeUDUnitsInLastPDU, EFalse);

				aPdus = iAdditionalInfo->SmsPDUArray().Count();

				if (aPdus > 255)

					{

	 				User::Leave(KErrOverflow);

					}

				}

			CleanupStack::PopAndDestroy(tmpArray);

			}

		else if (SmsPDU().TextConcatenated())

			{

			aPdus                 = SmsPDU().NumConcatenatedMessagePDUs();

			aUnconvertedChars     = 0;

			aDowngradedChars      = 0;

			aFreeUDUnitsInLastPDU = 0;

			}

		}

	} // CSmsMessage::GetEncodingInfoL

/**

 *  Gets the User Data Settings.

 *  

 *  @param aSettings User Data Settings

 *  @capability None

 */

EXPORT_C void CSmsMessage::UserDataSettings(TSmsUserDataSettings& aSettings) const

	{

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));

	aSettings.SetAlphabet(SmsPDU().Alphabet());

	aSettings.SetTextCompressed(SmsPDU().TextCompressed());

	TBool is16bit;

	TBool concatenated=SmsPDU().TextConcatenated(&is16bit);

	aSettings.SetTextConcatenated(concatenated,is16bit);

	} // CSmsMessage::UserDataSettings

/**

 *  Sets the User Data Settings.

 *  

 *  @param aSettings User Data Settings

 *  @capability None

 */

EXPORT_C void CSmsMessage::SetUserDataSettingsL(const TSmsUserDataSettings& aSettings)

	{

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));

	SmsPDU().SetAlphabet(aSettings.Alphabet());

	SmsPDU().SetTextCompressed(aSettings.TextCompressed());

	TBool is16bit;

	TBool concatenated=aSettings.TextConcatenated(&is16bit);

	SmsPDU().SetTextConcatenatedL(concatenated,is16bit);

	} // CSmsMessage::SetUserDataSettingsL

/**

 *  Optimizes the user data settings.

 *  

 *  The alphabet flag causes an alphabet to be chosen which preserves information

 *  in the message and makes the number of PDUs as small as possible.

 *  

 *  The compression settings flag is not supported.

 *  

 *  The compression flag causes compression to be switched on if the resultant

 *  number of PDUs is smaller.

 *  

 *  If user explicitly defines alphabet as UCS2 or 8-bit coding, this setting is preserved;

 *  otherwise, if 7-bit (default) alphabet can not support current text of message UCS2

 *  alphabet (Unicode) is used.

 *  

 *  The two concatenation flags are mutually exclusive as they deal with 8-bit

 *  and 16-bit referenced concatenation. Both flags cause compression to be switched

 *  off and if the message length is greater than the maximum message length,

 *  concatenation is switched on.

 *  

 *  @param aOptions Combination of TSmsOptimizationFlags

 *  @capability None

 */

EXPORT_C void CSmsMessage::OptimizeSettingsL(TInt aOptions)

	{

	__ASSERT_DEBUG(TextPresent(),Panic(KGsmuPanicTextNotPresent));

	__ASSERT_DEBUG(IsDecoded(),Panic(KGsmuPanicNotDecoded));

	if (aOptions&ESmsFlagOptimizeAlphabet && (SmsPDU().Alphabet()==TSmsDataCodingScheme::ESmsAlphabet7Bit))

		{

		TBool isSupported=ETrue;

		TInt numOfUnconvertibleChars;

		TInt indexOfFirstUnconvertibleChar;

		TInt size=iBuffer->Length();

		const TInt bufsize=128;

		TBuf<bufsize> buf;

		TInt extracted=0;

		TInt remaining=0;

		TInt toExtract=0;

		TInt pos=0;

		// Defect Fix. Previous for loop caused an access violation as extract size was set

		// to size of ibuffer not bufsize and caused a access violation when over 128. Implemented

		// fix copies the ibuffer in 128 chunks until its all done.

		while((pos<size) && isSupported)

			{

			remaining=(size - extracted);

			if(remaining>bufsize)

				toExtract=bufsize;

			else

				toExtract=remaining;

			iBuffer->Extract(buf,pos,toExtract);

			isSupported=IsSupportedL(buf,numOfUnconvertibleChars,indexOfFirstUnconvertibleChar);

			extracted=(extracted+toExtract);

			pos=extracted;

			}

		if(!isSupported)

			SmsPDU().SetAlphabet(TSmsDataCodingScheme::ESmsAlphabetUCS2);

		}

	} // CSmsMessage::OptimizeSettingsL

/**

 *  This function returns the currently requested alternative encoding method.

 * 

 *  In the case of incoming SMS messages received on the device, it will often

 *  be TSmsEncodingNone unless the Information Elements imply that an

 *  alternative encoding has been used.

 * 

 *  @return The currently selected encoding method.

 * 

 *  @capability None

 */

EXPORT_C TSmsEncoding CSmsMessage::Alternative7bitEncoding() const

	{