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

// Declares the CSmsProtocol, CSmsProtocolFamily, CSmsProvider and

// other classes used internally by them.

// Conditional includes

// 

//

/**

 @file

 @internalAll

*/

#ifndef SMSPROT_H

#define SMSPROT_H

#include <es_sock.h>

#include <es_prot.h>

#include <etelmm.h>

#include <es_ini.h>

#include <mmlist.h>

#include <cdblen.h>

#include "smsuset.h"

#include "smsuaddr.H"

#include "smspcomm.h"

#include "smspproc.h"

#include "nbbackuprestoreint.h"

class CSmsProvider;

class CFacadeSmsReassemblyStore;

class CSmsSegmentationStore;

class CLogWrapper;

class CSmsModemNotification;

class CSmsPDURead;

class CSmsPhoneEnumeration;

class CSmsMessageWrite;

class CSmsPDUDelete;

class CSmsReadParams;

class CSmsWriteParams;

class CSmspWriteQueue;

class CQueuedSmsMessage;

class CSmspDeleteQueue;

class CSmspSendQueue;

class CSmsPhoneInitialization;

class CSmsProtocolBootTimer;

class CBackupAndRestore;

class CSmspSetBearer;

/**

 *  CProtocolFamilyBase derived class which identifies the protocols

 *  we can create, and provides an overidden factory method for

 *  creating them.

 *  @internalComponent

 */

class CSmsProtocolFamily : public CProtocolFamilyBase

    {

public:

    static CSmsProtocolFamily * NewL();

    TInt Install();

    TInt Remove();

    CProtocolBase * NewProtocolL(TUint aSockType,TUint aProtocol);

    TUint ProtocolList(TServerProtocolDesc *& aProtocolList);

private:

    CSmsProtocolFamily();

    };

/**

 *  @internalComponent

 */

IMPORT_C CProtocolFamilyBase* InstallSMS();	// Force export

/**

 *  The main class for this protocol which handles requests

 *  from clients contending for services from the phone.

 *  @internalComponent

 */

class CSmsProtocol : public CProtocolBase,

                     public MSmsComm, 

                     public MNBBackupAndRestoreObserver

	{

friend class CSmsProvider;

public:

    static CSmsProtocol *NewL();

    virtual ~CSmsProtocol();

// Calls from the socket server which we implement

    CServProviderBase *NewSAPL(TUint aSocketType);

    void InitL(TDesC& aTag);

    void StartL(void);

    void Identify(TServerProtocolDesc *)const;

// Calls from the socket server which we don't implement

    virtual CHostResolvProvdBase *NewHostResolverL();

    virtual CServiceResolvProvdBase *NewServiceResolverL();

    virtual CNetDBProvdBase* NewNetDatabaseL();

// Calls from the socket server and other protocols which we just panic

    void BindL(CProtocolBase *aProtocol, TUint aId);

    virtual void BindToL(CProtocolBase *aProtocol);

    TInt Send(TDes8& aDes, TSockAddr *aTo,TSockAddr *aFrom,CProtocolBase* aSourceProtocol);

    void Process(TDes8& aDes,TSockAddr *aFrom,TSockAddr *to,CProtocolBase* aSourceProtocol);

    TInt GetOption(TUint aLevel,TUint aName,TDes8 &aOption,CProtocolBase* aSourceProtocol);

    TInt SetOption(TUint aLevel,TUint aName,const TDesC8& aOption,CProtocolBase* aSourceProtocol);

    void Error(TInt aError,CProtocolBase* aSourceProtocol);

// Functions called for WAP binding or for SAP creation

    virtual void AddSmsMessageObserverL(MSmsMessageObserver& aObserver);

    virtual TInt BindSmsMessageObserver(MSmsMessageObserver& aObserver,const TSmsAddr& aSmsAddr);

    virtual void RemoveSmsMessageObserver(const MSmsMessageObserver& aObserver);

    virtual TBool SmsAddrIsAlreadyUsed(const MSmsMessageObserver* aObserver,const TSmsAddr& aSmsAddr)const;

// Functions called by SAPs (e.g. WAPPROT)

    virtual void SendSmsMessage(CSmsMessage* aSmsMessage,MSmsMessageObserver& aObserver,TUint aOptions);

    virtual void CancelSendSmsMessage(MSmsMessageObserver& aObserver,TBool aCancelInternally=ETrue);

    virtual void EnumeratePhone(MSmsMessageObserver& aObserver);

    virtual void CancelEnumeratePhone(MSmsMessageObserver& aObserver);

    void WriteSmsMessage(CSmsMessage* aSmsMessage,MSmsMessageObserver& aObserver);

    void CancelWriteSmsMessage(MSmsMessageObserver& aObserver);

    virtual void DeleteSmsMessage(CSmsMessage* aSmsMessage,MSmsMessageObserver& aObserver);

    virtual void CancelDeleteSmsMessage(MSmsMessageObserver& aObserver);

    virtual void ReadSmsParameters(MSmsMessageObserver& aObserver);

    virtual void CancelReadSmsParams();

    virtual void WriteSmsParameters(CMobilePhoneSmspList* aMobilePhoneSmspList, MSmsMessageObserver& aObserver);

    virtual void CancelWriteSmsParams();

// MSmsComm Notifications used by active objects

    TInt ProcessMessageL(const CSmsMessage& aSmsMessage,const TSmsAddr* aOriginalSmsAddr,const CSmsMessage* aOriginalSmsMessage,TDes& aDes);

    void DeletePDUs(const CArrayFix<TGsmSmsSlotEntry>& aSlotArray, MSmsMessageObserver* aObserver);

    void ModemNotificationCompleted(TInt aStatus,RPhone::TModemDetection aNewState);

    void DiskSpaceMonitorStateChange(TSmsDiskSpaceMonitorStatus aStatus);

    void MessageSendCompleted(TInt aStatus);

    void PhoneEnumerationCompleted(TInt aStatus);

	inline RFs& FileSession();

	inline virtual TBool ObserverIsPresent(const MSmsMessageObserver& aObserver) const;

	const RMobilePhone::TMobilePhoneNetworkInfoV1& NetworkInfo() const;

    TBool NetworkInfoAvailable() const;

    // new function which deletes msg from the reassemblystore

    // by passing them the smsmessage class

    void DeleteSMSFromReaStoreL(const CSmsMessage& aSmsMessage);

    void MessageReadedSuccessfully();

    TBool AllocateLocalAddress(TSmsAddr& aAddr);

    TInt ExternalizeEnumeratedMessagesL(CSmsProvider& aProvider,TInt& aCount);

    static TBool IsAppPortSMS(const CSmsMessage& aSmsMessage);

protected:

    void CloseNow();

private:

    CSmsProtocol();

    TInt ObserverIndex(const MSmsMessageObserver& aObserver) const;

    void OrderSmsMessageObserver(const MSmsMessageObserver& aObserver);

    MSmsMessageObserver* MatchSmsAddressToObserver(const TSmsAddr& aAddr);

    MSmsMessageObserver* MatchSmsMessageToObserver(const CSmsMessage& aSmsMessage);

    static TBool IsMatch(const TSmsAddr& aSmsAddr, const CSmsMessage& aSmsMessage);

    static TBool MatchInformationElement(const CSmsMessage& aSmsMessage, CSmsInformationElement::TSmsInformationElementIdentifier aIeVal);

    void MatchCompleteSmsMessagesToObserverL(MSmsMessageObserver& aObserver,CArrayFix<TInt>& aIndexArray);

    static TBool MatchApplicationPort(const CSmsMessage& aSmsMessage,TUint aPort,TBool a16Bit);

    void NotifyMessageObservers(TInt aStatus);

 	TBool IsWapSMS(const CSmsMessage& smsmessage );

    inline TBool ClosingDown() const;

    inline void SetClosingDown(TBool aClosingDown);

    void CloseNowWrap();

    void PowerUp();			// Handles modem turning on or backup finishing

    void DoPowerUpL();

    void PowerDown();		// Handles modem turning off or backup starting

    void ProcessCompleteSmsMessagesL();

    TInt CheckPoweredUp() const;

    virtual void HandleBackupOrRestoreStartingL();

    virtual void HandleBackupOrRestoreCompleteL();

    void ReadConfigurableSettingsL(); // from smswap.sms.esk -> [customTimeoutSettings]

private:

    ///< Enumerated flag values for states of the protocol

    enum TSmsProtocolFlags

        {

        ESmsProtocolClosingDown=0x01			///< In the process of shutting down

        };

    enum

        {

        KNumSARStoreAccessesBeforePurging=8	///< Number of accesses to the segmentation & reassembly stores before purging

        };

    enum TSmsProtocolState

        {

        EPoweredDown,	///< SmsProt is not initialised and the phone is not swiched on

        EPoweredUp		///< SmsProt is powered up, phone switched on, ready for action

        } iState;

private:

    CArrayPtrFlat<MSmsMessageObserver> iSmsMessageObserverList;	///< List of current observers

    RTelServer iTelServer;                              ///< A session with the telephony server

    TBuf<KCommsDbSvrMaxFieldLength> iGsmTsyName;        ///< Name of the TSY

    RMobilePhone iGsmPhone;                             ///< ETEL phone subsession for intialisation and detection events

    RMobilePhone iEnumerationPhone;                     ///< ETEL phone subsession for enumerating the phone

    RMobilePhone iWritePhone;                           ///< ETEL phone subsession for writing messages

    RMobileSmsMessaging iSmsMessaging;                  ///< ETEL phone subsession for advanced messaging services

    TSmsSettings iSmsSettings;                          ///< Global SMS Protocol settings

    RMobileSmsMessaging::TMobileSmsCapsV1 iMobileSmsCaps;   // SMS messaging capabilities of the phone

    TInt iFlags;										///< Flags indicating current state of the protocol

    RFs iFs;                                            ///< A session with the file server

    CFacadeSmsReassemblyStore* iReassemblyStore;        ///< Pointer to the reassembly store

    TInt iNumReassemblyStoreAccesses;                   ///< Counter for number of accesses to the reassembly store

    CSmsSegmentationStore* iSegmentationStore;          ///< Pointer to the segmentation store

    TInt iNumSegmentationStoreAccesses;                 ///< Counter for number of accesses to the segmentation store

    CSmsModemNotification* iSmsModemNotification;		///< Pointer to object for handling modem detection events

    RPhone::TModemDetection iModemDetection;			///< The current modem detection state

    CSmsPDURead* iSmsPDURead;                           ///< Pointer to object for receiving SMS PDUs from ETEL

    CSmsMonitorDiskSpace* iSmsMonitorDiskSpace;         ///< Pointer to object for monitoring of disk space

    MSmsMessageObserver*    iPhoneEnumerationObserver;  ///< Pointer to the observer of any current enumeration

    CSmsPhoneEnumeration*   iSmsPhoneEnumeration;       ///< Pointer to object for enumerating messages on the phone

    CSmspSendQueue*     iSendQueue;                     ///< Queue of messages to send

    CSmspWriteQueue*    iWriteQueue;                    ///< Pointer to object for writing messages to the phone

    CSmspDeleteQueue*   iDeleteQueue;                   ///< Queue of PDUs to delete

    CSmsReadParams*    iSmsReadParams;                  ///< Pointer to object for reading SMS parameters

    CSmsWriteParams*   iSmsWriteParams;                 ///< Pointer to object for writing SMS parameters

    CSmsPhoneInitialization*   iSmsPhoneInitialization;

    CBackupAndRestore*         iBackupRestoreSession;

    CSmspSetBearer*            iSetBearer;              ///< Pointer to bearer object, used by message sender but cancelled from protocol

    CSmspReceiveMode*          iReceiveMode;            ///< Pointer to receive mode object, used by PDU reader but cancelled from protocol

    TInt iNext8BitPort;

    TInt iNext16BitPort;

    CSmsProtocolBootTimer*  iBootTimer;                 ///< Pointer to the CSmsProtocolBootTimer object

    };

/**

 *  A CServProviderBase derived class providing service access points to the

 *  SMS Protocol.

 *  @internalComponent

 */

class CSmsProvider : public CServProviderBase, public MSmsMessageObserver

	{

public:

    static CSmsProvider* NewL(CSmsProtocol& aProtocol);

    virtual ~CSmsProvider();

public:

// pure virtuals from CServProviderBase

    void Start();

    void LocalName(TSockAddr& aAddr) const;

    TInt SetLocalName(TSockAddr& aAddr);

    void RemName(TSockAddr& aAddr) const;

    TInt SetRemName(TSockAddr& aAddr);

    TInt GetOption(TUint aLevel,TUint aName,TDes8& aOption) const;

    void Ioctl(TUint aLevel,TUint aName,TDes8* aOption);

    void CancelIoctl(TUint aLevel,TUint aName);

    TInt SetOption(TUint aLevel,TUint aName,const TDesC8 &aOption);

    TInt Write(RMBufChain& aBufChain, TUint aOptions, TSockAddr* aAddr=NULL);

    TInt GetData(RMBufChain& aBufChain, TUint aLength, TUint aOptions, TSockAddr* aAddr=NULL);

    void ActiveOpen();

    void ActiveOpen(const TDesC8& aConnectionData);

    TInt PassiveOpen(TUint aQueSize);

    TInt PassiveOpen(TUint aQueSize,const TDesC8& aConnectionData);

    void Shutdown(TCloseType aOption);

    void Shutdown(TCloseType aOption,const TDesC8& aDisconnectionData);

    void AutoBind();

//  From MSmsMessageObserver

    const TSmsAddr& GetLocalAddress() const;

    void SetLocalAddress(const TSmsAddr& aSmsAddr);

    void ModemNotificationCompleted(TInt aStatus);

    void MessageSendCompleted(TInt aStatus);  //  aStatus is EPOC error or -(KFailureCauseOffset+failurecause)

    TInt MessageReceived(const CSmsMessage& aSmsMessage,TDes& aDes);  //  must return EPOC error or -(KFailureCauseOffset+failurecause)

    void EnumeratePhoneCompleted(TInt aStatus);

    void MessageWriteCompleted(TInt aStatus, const CSmsMessage* aSmsMessage = NULL);

    void MessageDeleteCompleted(TInt aStatus);

    void ReadSmsParamsCompleted(TInt aStatus,CMobilePhoneSmspList* aSmspList);

    void WriteSmsParamsCompleted(TInt aStatus);

    virtual TBool ClientConfirmsMessage()const;

    virtual TBool SmsAddrIsDuplicate(const MSmsMessageObserver* aObserver,const TSmsAddr& aAddr)const;

    TInt ExternalizeEnumeratedMessagesL(TInt& aCount);

    TInt ExternalizeMessageL(const CSmsMessage& aSmsMessage,TBool aAppend);

protected:

    CSmsProvider(CSmsProtocol& aProtocol);

    virtual TInt SecurityCheck(MProvdSecurityChecker* aSecurityChecker);

    void ConstructL();

private:

    TInt DoMessageReceivedL(const CSmsMessage& aSmsMessage);

    inline static TInt NumSegments(TInt aSize);

    void DoWriteL(const TDesC8& aData,TUint aOptions);

    TInt ExternalizeEnumeratedMesagesL(TInt& aCount);

    CSmsMessage* InternalizeMessageL();

    TInt ExternalizeParametersL(const CMobilePhoneSmspList& aMobilePhoneSmspList);

    CMobilePhoneSmspList* InternalizeParametersL();

    inline TBool ObserverAddedToProtocol() const;

    inline void SetObserverAddedToProtocol(TBool aAdded);

    inline TBool IoctlOutstanding() const;

    inline void SetIoctlOutstanding(TBool aOutstanding);

    CSmsMessage* InternalizeMessageL(	CBufSeg* aBufSeg);

    void PopulateBufferWithPDUSlotsL(const CSmsMessage& aSmsMessage);

private:

    ///< Enumerated flag values for current of the provider

    enum TSmsProviderFlags

        {

        ESmsProviderObserverAddedToProtocol=0x01,   ///< Registered as observer of the protocol

        ESmsProviderIoctlOutstanding=0x02           ///< Special SMS ioctl is outstanding

        };

private:

    CSmsProtocol& iProtocol;                    ///< Reference to the SMS Protocol object

    TSmsAddr iLocalAddress;                     ///< The local address of the access point

    TInt iFlags;                                ///< Flags indicating current state of the provider

    CArrayPtr<CBufSeg>* iRecvBufSegArray;       ///< Array of serialized SMS messages to be read from the socket

    TInt iSegmentIndex;                         ///< Index of next segment of current SMS message to read

    CBufSeg* iSendBufSeg;                       ///< SMS message segments written to the socket

    TUint iName;                                ///< The integer "name" of the current ioctl request

    TBool iEnumSocket;                          ///< this is enumeration client

    TInt iNumOfEnumeratedMessages;              ///< number of enumerated segments

    MProvdSecurityChecker* iSecurityChecker;    ///< ESOCK security checker object

    };

#include "smsprot.inl"

/**

 *  @internalComponent

 */

class CSmsProtocolBootTimer : public CTimer

	{

public:

    static CSmsProtocolBootTimer* NewL(CSmsProtocol& aSmsProtocol);

    virtual ~CSmsProtocolBootTimer();

    void Start(const TTimeIntervalMicroSeconds32& aTimeIntervalMicroSeconds32);

private:

    CSmsProtocolBootTimer(CSmsProtocol& aSmsProtocol);

    virtual void RunL();

protected:

    CSmsProtocol& iSmsProtocol;         ///< reference to owner CSmsProtocol object

    };

#endif // SMSPROT_H