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

 // This file defines the class CSmsMessage

 // 

 //

 /**

  @file

  @publishedAll

 */

 #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>

 /**

  *  @publishedAll

  */

 const TUint IoctlWriteSMSBufferSize = 256;

 const TUint KMaxMobileNameSize = 32;

 class CSmsBufferBase;

 class CSmsCompressedBuffer;

 class TSmsUserDataSettings;

 class CSmsEMSBufferSegmenter;

 class CEmsUserPrompt;

 class CEmsObjectDistribution;

 class CSmsIEOperation;

 class CSmsNonIEOperation;

 class CSmsMessageAdditionalAttributes;

 /**

  *  This class is used in CSmsMessage only.

  *  @publishedAll

  */

 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;

     };

 struct TEncodeParams

 	{

 	const TTime* iTimeStamp;

 	const TTimeIntervalSeconds* iTimeIntervalInSeconds;		

 	};

 /**

  *  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 (void*)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(CSmsEMSBufferSegmenter& aSegmenter, TUint& aCharsAdded,

 			                                              TBool aDoEncode, TSmsEncoding& aEncoding,

 			                                              RPointerArray<CEmsInformationElement>& aCorrectedFormatingIEArray,

 			                                              TUint& aCurEMSIEno, TUint& aBaseAddr);

 	TBool AddEMSInformationElementsToSingleSegmentMessageL(CSmsEMSBufferSegmenter& aSegmenter,

 			                                               TSmsEncoding aEncoding);

 	void AddControlInformationElementsToMultiSegmentMessageL(TBool aDoEncode);

 	void AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::TInformationElementCategory aCategory, TBool aMandatoryInPDU, TBool aDoEncode);

 	void AddCurrentPDUToPDUArrayL(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 FindSchemeL(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 

 	 */

 	CSmsMessageAdditionalAttributes*  iAdditionalInfo;

 	};

 #include <gsmumsg.inl>

 #endif // !defined __GSMUMSG_H__