diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/gsmumsg.h --- a/epoc32/include/gsmumsg.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/gsmumsg.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,367 @@ -gsmumsg.h +// 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 +#include +#include +#include +#include +#include "gsmupdu.h" + +#include + +/** + * @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 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& aSmsArray, TInt aReference=0); + IMPORT_C void DecodeMessagePDUsL(const CArrayFix& aSmsArray); + IMPORT_C const RPointerArray& GetEMSInformationElementsL()const; + IMPORT_C void AddEMSInformationElementL(const CEmsInformationElement& aEmsIE); + IMPORT_C RPointerArray* 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& aSmsArray); + IMPORT_C void CopyEmsElementsL(CSmsMessage& aToMessage) const; + IMPORT_C void AddSlotL(const TGsmSmsSlotEntry& aSlot); + IMPORT_C TBool MatchSlots(const CArrayFixFlat& 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& 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& aSmsArray,TInt aReference,const CSmsBufferBase& aBuffer, + TInt& aUnconvertedChars, TInt& aDowngradedChars, + TInt& aFreeUDUnitsInLastPDU, TBool aDoEncode=ETrue); + void DecodeBufferL(CArrayPtr& aSmsPDUArray,CSmsBufferBase& aBuffer); + TBool EncodeIntoSinglePDUL(CArrayFix& 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& aSmsArray,CSmsEMSBufferSegmenter& aSegmenter,TUint& aCharsAdded,TBool aDoEncode,TSmsEncoding& aEncoding,RPointerArray& aCorrectedFormatingIEArray,TUint& aCurEMSIEno,TUint& aBaseAddr); + TBool AddEMSInformationElementsToSingleSegmentMessageL(CSmsEMSBufferSegmenter& aSegmenter, + TSmsEncoding aEncoding); + void AddControlInformationElementsToMultiSegmentMessageL(CArrayFix& aSmsArray); + void AddControlInformationElementsToMultiSegmentMessageL(TSmsInformationElementCategories::TInformationElementCategory aCategory, TBool aMandatoryInPDU, CArrayFix& aSmsArray); + void AddCurrentPDUToSmsArrayL(CArrayFix& 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& 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& aSmsPDUArray); + void InstallTPSRRInformationL(const CArrayPtr& aSmsPDUArray, TInt aSegmentSequenceNum); + void EncodingTPSRRFromSchemesIntoSinglePDUL(); + void DecodeOnlyTextL(CArrayPtr& 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* iInformationElementArray; + CCnvCharacterSetConverter* iCharacterSetConverter; + +public: + CArrayFixFlat 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 + +#endif // !defined __GSMUMSG_H__