// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// This file defines the class CSmsMessage

// 

//

/**

 @file

*/

#ifndef __GSMUMSG_H__

#define __GSMUMSG_H__

#include <e32std.h>

#include <f32file.h>

#include <gsmuetel.h>

#include <charconv.h>

#include <gsmunmspacemobstore.h>

#include "gsmupdu.h"

#include <emsinformationelement.h>

/**

 *  @internalComponent

 */

const TUint IoctlWriteSMSBufferSize = 256;

const TUint KMaxMobileNameSize = 32;

class CSmsBufferBase;

class CSmsCompressedBuffer;

class TSmsUserDataSettings;

class CSmsEMSBufferSegmenter;

class CGsmCompressionBase;

class CEmsUserPrompt;

class CEmsObjectDistribution;

class CSmsIEOperation;

class CSmsNonIEOperation;

/**

 *  This class is used in CSmsMessage only.

 *  @internalComponent

 */

class TGsmSmsSlotEntry

	{

public:

	IMPORT_C TGsmSmsSlotEntry();

public:

    TInt iIndex;

    TBuf<KMaxMobileNameSize> iStore; 				// equivalent to RMobilePhone::TMobileName

	void InternalizeL(RReadStream& aStream);

	void ExternalizeL(RWriteStream& aStream) const;

    };

/**

 *  Represents a complete SMS message.

 *  

 *  This class can:

 *  

 *  Internalise and externalise its data

 *  

 *  Encode/decode itself to/from one or more SMS PDU's

 *  

 *  SMS Message Data is stored in the CSmsBufferBase iBuffer. SMS Message Settings

 *  are stored in the CSmsPDU iSmsPDU.

 *  @publishedAll

 *  @released 

 */

class CSmsMessage : public CBase

	{

public:

/** User data optimisation flags. */

	enum TSmsOptimizationFlags

		{

	/**

	 *  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. 

	 */

		ESmsFlagOptimizeAlphabet=0x01,

	/**

	 *  8-bit referenced concatenation.

	 *  

	 *  This causes compression to be switched off and if the message length is greater

	 *  	than the maximum message length, concatenation is switched on. 

	 */

		ESmsFlagOptimizeConcatenation=0x08,

	/**

	 *  16-bit referenced concatenation.

	 *  

	 *  This causes compression to be switched off and if the message length is greater

	 *  	than the maximum message length, concatenation is switched on. 

	 */

		ESmsFlagOptimizeConcatenation16BitReference=0x10,

		};

/** Flags that indicate whether a message is stored. */

	enum TMobileSmsStorage

		{

	/** No storage. */

		ESmsNoStorage=0x00,

	/** SIM storage. */

		ESmsSIMStorage=0x04,

	/** Phone storage. */

		ESmsPhoneStorage=0x08,

	/** Combined storage. */

		ESmsCombinedStorage=0x0C

		};

	enum TTimeIntervalsRepresentedInSeconds

		{

		E15MinutesRepresentedInSeconds = 15 * 60,

		EMaximumSeconds                = 79 * E15MinutesRepresentedInSeconds

		                                      // Harmonised with maximum offset allowed for

                                              // Service Centre Time Stamp per 23.040 V4.4 Sect 9.2.3.11.

		};

public:

	IMPORT_C static CSmsMessage* NewL(RFs& aFs, const TGsmSms& aGsmSms,CSmsBufferBase* aBuffer, TBool aIsRPError=EFalse,TBool aIsMobileTerminated=ETrue);

	IMPORT_C static CSmsMessage* NewL(RFs& aFs, CSmsPDU::TSmsPDUType aType,CSmsBufferBase* aBuffer,TBool aIsRPError=EFalse);

	IMPORT_C ~CSmsMessage();

	inline CSmsPDU::TSmsPDUType Type() const;

	inline TBool IsComplete() const;

	inline TBool IsDecoded() const;

	inline TMobileSmsStorage Storage() const;

	inline void SetStorage(TMobileSmsStorage aStorage);

	inline NMobileSmsStore::TMobileSmsStoreStatus Status() const;

	inline void SetStatus(NMobileSmsStore::TMobileSmsStoreStatus aStatus);

	inline TInt LogServerId() const;

	inline void SetLogServerId(TInt aId);

	inline const TTime& Time() const;

	inline void SetTime(const TTime& aTime);

	IMPORT_C TTimeIntervalSeconds UTCOffset() const;

	IMPORT_C TBool SetUTCOffset(const TTimeIntervalSeconds& aTimeOffset);

    IMPORT_C void  SetDecodedOnSIM(TBool aOnSim);

    IMPORT_C TBool DecodedOnSim();

    IMPORT_C void  SetForwardToClient(TBool aForward);

    IMPORT_C TBool ForwardToClient();

	inline CSmsPDU& SmsPDU();

	inline const CSmsPDU& SmsPDU() const;

	inline TPtrC ServiceCenterAddress() const;

	inline void SetServiceCenterAddressL(const TDesC& aAddress);

	inline void ParsedServiceCenterAddress(TGsmSmsTelNumber& aParsedAddress) const;

	inline void SetParsedServiceCenterAddressL(const TGsmSmsTelNumber& aParsedAddress);

	inline TPtrC ToFromAddress() const;

	inline void SetToFromAddressL(const TDesC& aAddress);

	inline void ParsedToFromAddress(TGsmSmsTelNumber& aParsedAddress) const;

	inline void SetParsedToFromAddressL(const TGsmSmsTelNumber& aParsedAddress);

	IMPORT_C void InternalizeWithoutBufferL(RReadStream& aStream);

	IMPORT_C void ExternalizeWithoutBufferL(RWriteStream& aStream) const;

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	inline CSmsBufferBase& Buffer();

	inline const CSmsBufferBase& Buffer() const;

//  Functions related to encoding/decoding the text buffer

	IMPORT_C TBool TextPresent() const;

	IMPORT_C TInt NumMessagePDUsL();

	IMPORT_C TInt MaxMessageLength() const;

	IMPORT_C TInt MessageLengthL();

	IMPORT_C void GetEncodingInfoL(TInt& aPdus, TInt& aUnconvertedChars,

                                   TInt& aDowngradedChars, TInt& aFreeUDUnitsInLastPDU);

	IMPORT_C void UserDataSettings(TSmsUserDataSettings& aSettings) const;

	IMPORT_C void SetUserDataSettingsL(const TSmsUserDataSettings& aSettings);

	IMPORT_C void OptimizeSettingsL(TInt aOptions);

	IMPORT_C TSmsEncoding Alternative7bitEncoding() const;

	IMPORT_C TInt SetAlternative7bitEncoding(TSmsEncoding aEncoding);

	IMPORT_C TBool IsSupportedL(const TDesC& aDes,TInt& aNumberOfUnconvertibleCharacters, TInt& aIndexOfFirstUnconvertibleCharacter);

	IMPORT_C TBool IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,

			                    TInt& aNumberOfDowngradedCharacters,

			                    TInt& aNumberRequiringAlternativeEncoding,

			                    TInt& aIndexOfFirstUnconvertibleCharacter) const;

	IMPORT_C void EncodeMessagePDUsL(CArrayFix<TGsmSms>& aSmsArray, TInt aReference=0);

	IMPORT_C void DecodeMessagePDUsL(const CArrayFix<TGsmSms>& aSmsArray);

	IMPORT_C const RPointerArray<const CEmsInformationElement>& GetEMSInformationElementsL()const;

	IMPORT_C void AddEMSInformationElementL(const CEmsInformationElement& aEmsIE);

	IMPORT_C RPointerArray<CEmsInformationElement>* RemoveEMSInformationElementsL(const TUint aStartPosition,const TSmsId aEmsId);

	IMPORT_C CEmsInformationElement* RemoveEMSInformationElementL(const TUint aStartPosition,const TSmsId aEmsId);

	IMPORT_C void ResetEMSL();

	IMPORT_C TBool EncodeIntoSinglePDUL(CArrayFix<TGsmSms>& aSmsArray);

	IMPORT_C void CopyEmsElementsL(CSmsMessage& aToMessage) const;

	IMPORT_C void AddSlotL(const TGsmSmsSlotEntry& aSlot);

	IMPORT_C TBool MatchSlots(const CArrayFixFlat<TGsmSmsSlotEntry>& aSlotArray);

// E-mail header

 	IMPORT_C void AddEmailHeaderL(const TDesC& aEmailHeader,const TDesC& aEmailBody);

 	IMPORT_C TBool IsEmailHeader() const;

 	IMPORT_C TBool GetEmailHeaderL(HBufC** aEmailHeader,HBufC** aEmailBody);

 	void InstallEmailHeaderInformationElementL(CSmsUserData& aUserData,TInt& aHeaderLength);

 	void InstallEmailHeaderInformationElementL(CSmsCommand& aCommand,TInt& aHeaderLength);

	inline void Set16BitConcatenation(TBool aIs16BitConcatenation);

	inline TBool Is16BitConcatenation()const;

	IMPORT_C void UpdateSlotsL(TDesC8& aBuf);

// Version information

	IMPORT_C TInt Version();

	// from this point downwards, all functions should be published internally only

	IMPORT_C TInt SetVersion(TInt aVersion);

 	IMPORT_C void InternalizeWithoutBufferAndVersionL(RReadStream& aStream);

	IMPORT_C void ExternalizeWithoutBufferAndVersionL(RWriteStream& aStream) const;

 	IMPORT_C void InternalizeBufferL(RReadStream& aStream);

	IMPORT_C void ExternalizeBufferL(RWriteStream& aStream) const;

 	IMPORT_C void InternalizeVersionL(RReadStream& aStream);

	IMPORT_C void ExternalizeVersionL(RWriteStream& aStream) const;

    void* AdditionalInfo() {return iAdditionalInfo;};

    IMPORT_C CSmsIEOperation& GetOperationsForIEL(CSmsInformationElement::TSmsInformationElementIdentifier) const;

    IMPORT_C CSmsNonIEOperation& GetOperationsForNonIEL(TSmsNonIEIdentifier) const;

  	IMPORT_C TSmsStatusReportScheme Scheme() const;

	IMPORT_C void DecodePartialCompleteMessagePDUsL(const CArrayFix<TGsmSms>& aSmsArray, TBool aLastPartialCompleteMsg);

private:

	CSmsMessage(RFs& aFs, CSmsBufferBase* aBuffer);

	void ConstructL(const TGsmSms& aGsmSms, TBool aIsRPError,TBool aIsMobileTerminated);

	void ConstructL(CSmsPDU::TSmsPDUType aType,TBool aIsRPError);

	void CreateControlIEOperationsClassesL();

	void CreateControlNonIEOperationsClassesL();

	inline void SetIsComplete(TBool aIsComplete);

	inline void SetIsDecoded(TBool aIsDecoded);

	inline TBool BinaryData() const;

	TInt ConvertedBufferLengthL(const CSmsBufferBase& aBuffer);

	void EncodeBufferL(CArrayFix<TGsmSms>& aSmsArray,TInt aReference,const CSmsBufferBase& aBuffer,

			           TInt& aUnconvertedChars, TInt& aDowngradedChars,

			           TInt& aFreeUDUnitsInLastPDU, TBool aDoEncode=ETrue);

	void DecodeBufferL(CArrayPtr<CSmsPDU>& aSmsPDUArray,CSmsBufferBase& aBuffer);

	TBool EncodeIntoSinglePDUL(CArrayFix<TGsmSms>& aSmsArray, TInt& aUnconvertedChars,

			                   TInt& aDowngradedChars, TInt& aFreeUDUnitsInLastPDU);

	void PrepareCommandMessageL(void);

	void InstallEmsInformationElementsL(CSmsUserData& aUserData, TInt aStartPosition);

	void InstallEmsInformationElementsL(CSmsCommand& aCommand, TInt aStartPosition);

	void InstallControlInformationElementsL(CSmsUserData& aUserData, TInt aSegmentSequenceNum);

	void InstallControlInformationElementsL(CSmsCommand& aCommand);

	TBool AddEMSInformationElementsToMultiSegmentMessageL(CArrayFix<TGsmSms>& aSmsArray,CSmsEMSBufferSegmenter& aSegmenter,TUint& aCharsAdded,TBool aDoEncode,TSmsEncoding& aEncoding,RPointerArray<CEmsInformationElement>& aCorrectedFormatingIEArray,TUint& aCurEMSIEno,TUint& aBaseAddr);

	TBool AddEMSInformationElementsToSingleSegmentMessageL(CSmsEMSBufferSegmenter& aSegmenter,

			                                               TSmsEncoding aEncoding);

	void AddControlInformationElementsToMultiSegmentMessageL(CArrayFix<TGsmSms>& aSmsArray);

	void AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::TInformationElementCategory aCategory, TBool aMandatoryInPDU, CArrayFix<TGsmSms>& aSmsArray);

	void AddCurrentPDUToSmsArrayL(CArrayFix<TGsmSms>& aSmsArray,TBool aDoEncode);

	TBool AddIEToUserDataL(CEmsInformationElement* aIe, TInt aCharsAlreadyAdded,TUint& aCharsAddedToCurrentPDU,CSmsEMSBufferSegmenter& aSeg);

	TInt FillPduL(CSmsEMSBufferSegmenter& aSeg, TInt aNumChars, TSmsEncoding aEncoding);

	TInt NumMessageEmsPDUsL();

	void CorrectFormattingL(TUint aCharsAddedToCurrentPDU,RPointerArray<CEmsInformationElement>& aCorrectedFormatingIEArray,TUint aBaseAddr);

	void CorrectFormattingInSinglePDUL();

	void ResetWorkingPDUL();

	TBool CanBeRemoved(const CEmsInformationElement& aIE, TUint aIEIndex);

	void AddEmsUserPromptL(const CEmsUserPrompt& aEmsIE);

	void AddEmsObjectDistributionL(const CEmsObjectDistribution& aObjectDistributionIE);

	void UpdateUserPromptAndODIElementsStartPosition();

	TInt AddReceivedEmsInformationElement(CEmsInformationElement* aIE);

	TSmsStatusReportScheme FindScheme(const CArrayPtr<CSmsPDU>& aSmsPDUArray);

	void InstallTPSRRInformationL(const CArrayPtr<CSmsPDU>& aSmsPDUArray, TInt aSegmentSequenceNum);

	void EncodingTPSRRFromSchemesIntoSinglePDUL();

	void DecodeOnlyTextL(CArrayPtr<CSmsPDU>& aSmsPDUArray,CSmsBufferBase& aBuffer);

	void AddIncompleteMessageInfoL(TInt aStartPDU, TInt aEndPDU, TBool aLastPartialCompleteMsg);

	void MergeAlternative7bitEncoding(TSmsEncoding aEncoding) const;

private:

	enum TSmsMessageFlags

		{

		ESmsFlagIsComplete=0x01,

		ESmsFlagIsDecoded=0x02,

		ESmsStorageMask=0x0C,

		ESmsUTCOffsetSecondGranularityMask  =0x1FFFF0,//Bits needed to represent 79 * 15 * 60 seconds

		ESmsUTCOffsetSignBit                =0x200000

		};

	enum TTimeBitMaskOffsets

		{

		ESecondBitOffset   =  4,

		ESignBitOffset     = 21

		};

    enum TDecodedOnSimBit

        {

        EDecodedOnSimBit = 0x80000000

        };

    enum TForwardToClientBit

        {

        EForwardToClientBit = 0x40000000

        };

private:

	TInt iFlags;

	NMobileSmsStore::TMobileSmsStoreStatus iStatus;

	TInt iLogServerId;

	TTime iTime;

	CSmsPDU* iSmsPDU;

	CSmsBufferBase* iBuffer;

	RFs& iFs;

	TBool iIs16BitConcatenation;

	RPointerArray<CEmsInformationElement>* iInformationElementArray;

	CCnvCharacterSetConverter* iCharacterSetConverter;

public:

	CArrayFixFlat<TGsmSmsSlotEntry> iSlotArray; ///< Array for slots

/**

 *  SMS versions

 */

	enum TSmsMessageVersion

		{

	/** The default value. */

		ESmsMessageV0, 

	/** Release 6 SMS Support */	

		ESmsMessageV1, 

	/** Latest version */

		ESmsMessageV2,

	/**	Incomplete Class0 Information Support	*/

		ESmsMessageV3,

		ESmsIncompleteClass0MessageV = ESmsMessageV3,

	/** National language 7bit encoding support */

		ESmsMessageV4

		// for all other versions the corresponding enum values would be added i.e. ESmsMessageV5, etc. 

		};

protected:

/**

 *  iVersion is the version of CSmsMessage. This parameter will be

 *  used to identify what iAdditionalInfo points to for that particular

 *  version of CSmsMessage

 */

	TInt iVersion;

/**

 *  iAdditionalInfo would point to any new added data structure.

 *  iVersion would identify which data structure is valid for that

 *   *  particular version of CSmsMessage 

 */

	void* iAdditionalInfo;

	};

#include <gsmumsg.inl>

#endif // !defined __GSMUMSG_H__