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

//

// INCLUDE FILES

#include "cmmsmstsy.h"

#include "cmmphonetsy.h"

#include "cmmsmsstoragetsy.h"

#include "cmmsmsgsmext.h"

#include "cmmtsyreqhandlestore.h"

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "MmTsy_numberOfSlots.h"

#include <ctsy/serviceapi/cmmsmsutility.h>

#include "cmmsmssendrequest.h"

#include <ctsy/serviceapi/mstktsysatservice.h>  

#include "CMmCommonStaticUtility.h"

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <etelsat.h>  // for Sat MO SM Control error values

// ======== MEMBER FUNCTIONS ========

CMmSmsTsy::CMmSmsTsy():

    iReqHandleType(EMultimodeSmsReqHandleUnknown)

    {

    }

void CMmSmsTsy::ConstructL()

    {

#ifdef REQHANDLE_TIMER   

    //create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone, 

        EMultimodeSmsMaxNumOfRequests, iSmsReqHandles );

#else

    // create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMultimodeSmsMaxNumOfRequests, iSmsReqHandles );

#endif // REQHANDLE_TIMER   

    // Reset all CMmSmsTsy variables

    ResetVariables();

    // SMS message array

    iSmsMsgArray = new ( ELeave ) CArrayPtrFlat<TSmsMsg>( 1 );

    // Create GSM mode SMS extension

    iMmSmsExtInterface = CMmSmsGsmExt::NewL();

    // register sms tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject( 

        CMmMessageManagerBase::ESmsMessagingTsy, this );

    // at startup, there is no pending Send request

    iSmsSendReq = NULL;

    // Initialise off-line/on-line mode variable with information

    // from PhoneTsy. After object construction, this information

    // will be updated using DOS indications.

    TRfStateInfo phoneRfInfo = iMmPhone->GetRfStateInfo();

    if ( ERfsStateInfoInactive == phoneRfInfo )

        {

        iIsOffline = ETrue;

        }

    else

        {

        iIsOffline = EFalse;

        }

    // there's no pending ResumeSmsReception request at startup

    iResumeSmsReceptionPending = EFalse;

    // Initialization for sms NoFdnCheck

    iSmsNoFdnCheckFlag = ESmsNoFdnCheckUnknown;

    iExpectAckOrNack = 0;

    }

CMmSmsTsy* CMmSmsTsy::NewL(

    CMmPhoneTsy* aMmPhone )

    {

    CMmSmsTsy* aMmSmsTsy = new ( ELeave ) CMmSmsTsy();

    CleanupClosePushL(*aMmSmsTsy);

    aMmSmsTsy->iMmPhone = aMmPhone;

    aMmSmsTsy->ConstructL();

    CleanupStack::Pop();

    return aMmSmsTsy;

    }

CMmSmsTsy::~CMmSmsTsy()

    {

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

        iMmPhone->MessageManager()->DeregisterTsyObject(this);

        // Release the SMS routing from DOS to TSY.

        // Send request to the Domestic OS layer. Ignore if it leaves

        TInt trapError = KErrNone;

        TRAP( trapError, iMmPhone->MessageManager()->HandleRequestL( 

                EMmTsyDeactivateSmsRouting ); );

        }

    // try to complete send sms message.

    if ( iTsySatMessaging )

        {

        iTsySatMessaging->CompleteSendSmsMessage( KErrAccessDenied );

        }

    if ( iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        iTsyReqHandleStore = NULL;

        }

    if ( iSmsMsgArray )

        {

        iSmsMsgArray->ResetAndDestroy();

        delete iSmsMsgArray;

        iSmsMsgArray = NULL;

        }

    // Delete extension object

    if ( iMmSmsExtInterface )

        {

        delete iMmSmsExtInterface;

        iMmSmsExtInterface = NULL;

        }

    if ( iMmPhone )

        {

        iMmPhone->SetSmsSession( NULL );

        iMmPhone = NULL;

        }

    if ( iSmsSendReq )

        {

        delete iSmsSendReq;

        iSmsSendReq = NULL;

        }

    if ( iSMSPClientId )

        {

        delete iSMSPClientId;

        iSMSPClientId = NULL;

        }

	// set pointers to NULL

	iMmSmsStorageTsy = NULL;

	iTsySatMessaging = NULL;

	iNotifyReceiveModeChangePtr = NULL;

	iReceiveMessageParamsPtr = NULL;

	iReceiveMessagePduPtr = NULL;

	iNotifySmsBearerPtr = NULL;

	iSendMessageMsgAttrPckgPtr = NULL;

	iGetMessageStoreInfoPtr = NULL;

	iStoreSmspBufferPtr = NULL;

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::Init 

// Initialisation method that is called from ETel Server

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

void CMmSmsTsy::Init()

    {

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::OpenNewObjectByNameL 

// Creates new object and returns a pointer to it

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

CTelObject* CMmSmsTsy::OpenNewObjectByNameL( 

    const TDesC& aName )

    {

    if ( aName.Compare( KETelIccSmsStore ) == KErrNone )

        {

        iMmSmsStorageTsy = CMmSmsStorageTsy::NewL( this, iMmPhone, 

            iMmSmsExtInterface, iTsyReqHandleStore );

        return iMmSmsStorageTsy;

        }

    // ME memory (KETelMeSmsStore) and combined memory (KETelCombinedSmsStore) 

    // are not supported

    User::Leave( KErrNotSupported );

    //lint -e{527} "unreachable code"

    return NULL;

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::OpenNewObjectL 

// Creates new object and returns a pointer to it

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

CTelObject* CMmSmsTsy::OpenNewObjectL( 

    TDes& /*aNewName*/ )   

    {

    // Not supported

    User::Leave( KErrNotSupported );

    //lint -e{527} "unreachable code"

    return NULL;

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::ExtFunc 

// ExtFunc is called by the server when it has a "extended", 

// i.e. non-core ETel request for the TSY. To process a request handle, 

// request type and request data are passed to the TSY

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

TInt CMmSmsTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TAny* dataPtr = aPackage.Ptr1();

    TInt ret( KErrNone );

    // before processing further the request, check if offline mode status

    // is enabled and if the given request can be perfomed in that case.

    if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() &&

        !IsRequestPossibleInOffline( aIpc ) )  

        {

        TInt error = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral, 

                KErrGsmOfflineOpNotAllowed );

        // Complete the request with appropiate error

        ReqCompleted ( aTsyReqHandle, error ); 

        }

    else

        {

        switch ( aIpc )

            {

            // SMS messaging requests that doesn't need trapping

            case EMobileSmsMessagingGetCaps:

                ret = GetCaps( aTsyReqHandle, aPackage.Des1n() );

                break;

            case EMobileSmsMessagingGetReceiveMode:

                ret = GetReceiveMode( aTsyReqHandle, reinterpret_cast< 

					RMobileSmsMessaging::TMobileSmsReceiveMode* >( dataPtr ) );

                break;

            case EMobileSmsMessagingGetMoSmsBearer:

                ret = GetMoSmsBearer( aTsyReqHandle, reinterpret_cast< 

                    RMobileSmsMessaging::TMobileSmsBearer* >( dataPtr) );

                break;

            case EMobileSmsMessagingSetMoSmsBearer:

                ret = SetMoSmsBearer( aTsyReqHandle, reinterpret_cast< 

                    RMobileSmsMessaging::TMobileSmsBearer*>( dataPtr) );

                break;

            case EMobileSmsMessagingEnumerateMessageStores:

                ret = EnumerateMessageStores( aTsyReqHandle, 

                    reinterpret_cast< TInt* >( dataPtr ) );

                break;

            case EMobileSmsMessagingGetSmspListPhase2:

                ret = ReadSmspListPhase2( aTsyReqHandle, reinterpret_cast< 

                    RMobilePhone::TClientId*>( dataPtr ), aPackage.Des2n() );

                break;

            // SMS messaging requests that need trapping

            default:

                // Ensure the ReqHandleType is unset.

                // This will detect cases where this method indirectly calls itself

                // (e.g. servicing a client call that causes a self-reposting notification to complete and thus repost).

                // Such cases are not supported because iReqHandleType is in the context of this class instance,

                // not this request, and we don't want the values set by the inner request and the outer request

                // interfering with each other.

                __ASSERT_DEBUG(iReqHandleType==EMultimodeSmsReqHandleUnknown, User::Invariant());

                TInt leaveCode( KErrNone );

                TRAP( leaveCode, ret = DoExtFuncL( aTsyReqHandle, aIpc, 

                    aPackage ); );

                if ( KErrNone != leaveCode )

                    {

                    ReqCompleted( aTsyReqHandle, leaveCode );

                    }

                //save request handle

                if ( EMultimodeSmsReqHandleUnknown != iReqHandleType )

                    {

#ifdef REQHANDLE_TIMER

                    SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

                    //Never comes here. See SetTypeOfResponse.

                    iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, 

                        aTsyReqHandle );

#endif // REQHANDLE_TIMER

                    // We've finished with this value now. Clear it so it doesn't leak

                    //  up to any other instances of this method down the call stack

                    iReqHandleType = EMultimodeSmsReqHandleUnknown;

                    }

                break;

            }

        }

    return ret;

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::DoExtFuncL 

// DoExtFuncL calls messaging methods that can leave

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

TInt CMmSmsTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        // SMS messaging requests

        case EMobileSmsMessagingSetReceiveMode:

            ret = SetReceiveMode( aTsyReqHandle, reinterpret_cast<

				RMobileSmsMessaging::TMobileSmsReceiveMode* >( dataPtr ) );

            break;

        case EMobileSmsMessagingNotifyReceiveModeChange:

            ret = NotifyReceiveModeChange( reinterpret_cast< 

                RMobileSmsMessaging::TMobileSmsReceiveMode*>( dataPtr) );

            break;

        case EMobileSmsMessagingReceiveMessage:

            ret = ReceiveMessageL( aTsyReqHandle, aPackage.Des1n(), 

                aPackage.Des2n() );

            break;

        case EMobileSmsMessagingAckSmsStored:

            ret = AckSmsStoredL( aTsyReqHandle, aPackage.Des1n(),

                reinterpret_cast< TBool* >( dataPtr2 ) );

            break;

        case EMobileSmsMessagingNackSmsStored:

            ret = NackSmsStoredL( aTsyReqHandle, aPackage.Des1n(),

                reinterpret_cast< TInt* >( dataPtr2 ) );

            break;

        case EMobileSmsMessagingResumeSmsReception:

            ret = ResumeSmsReceptionL( aTsyReqHandle );

            break;

        case EMobileSmsMessagingNotifyMoSmsBearerChange:

            ret = NotifyMoSmsBearerChange( reinterpret_cast< 

                RMobileSmsMessaging::TMobileSmsBearer*> ( dataPtr ) );

            break;

        case EMobileSmsMessagingSendMessage:

            {

            iSmsNoFdnCheckFlag = ESmsNoFdnCheckNotUsed;

            ret = SendMessageL( aTsyReqHandle, aPackage.Des1n(),

                aPackage.Des2n() );

            }

            break; 

        case EMobileSmsMessagingSendMessageNoFdnCheck:

            {

            iSmsNoFdnCheckFlag = ESmsNoFdnCheckUsed;

            ret = SendMessageL( aTsyReqHandle, aPackage.Des1n(),

                aPackage.Des2n() );

            }

            break;

        case EMobileSmsMessagingGetMessageStoreInfo:

            ret = GetMessageStoreInfoL( aTsyReqHandle,

                reinterpret_cast< TInt* >( dataPtr ), aPackage.Des2n() );

            break;

        case EMobileSmsMessagingGetSmspListPhase1:

            ret = ReadSmspListPhase1L( aTsyReqHandle,

                reinterpret_cast< RMobilePhone::TClientId*>( dataPtr ),

                reinterpret_cast< TInt* >( dataPtr2 ) );

            break;

        case EMobileSmsMessagingNotifySmspListChange:

            ret = NotifySmspListChange();

            break;

        case EMobileSmsMessagingStoreSmspList:

            ret = StoreSmspList( aTsyReqHandle, aPackage.Des1n() );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

// --------------------------------------------------------------------------- 

// CMmSmsTsy::ReqModeL 

// When the ETel server receives an "extension" client request, 

// it will pass the IPC request number down to the TSY in order to find out 

// what type of request it is

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

CTelObject::TReqMode CMmSmsTsy::ReqModeL( 

    const TInt aIpc )     

    {

    CTelObject::TReqMode ret = 0;

    switch ( aIpc )

        {

        // Non-flow Controlled Services

        case EMobileSmsMessagingGetCaps:

        case EMobileSmsMessagingGetMoSmsBearer:

        case EMobileSmsMessagingSetMoSmsBearer:

        case EMobileSmsMessagingGetReceiveMode:

        case EMobileSmsMessagingEnumerateMessageStores:

        case EMobileSmsMessagingGetSmspListPhase2:

        case EMobileSmsMessagingAckSmsStored:

        case EMobileSmsMessagingNackSmsStored:

        case EMobileSmsMessagingSendMessage:

        case EMobileSmsMessagingSendMessageNoFdnCheck:

        case EMobileSmsMessagingResumeSmsReception:

        case EMobileSmsMessagingGetMessageStoreInfo:

        case EMobileSmsMessagingGetSmspListPhase1:

        case EMobileSmsMessagingStoreSmspList:

        case EMobileSmsMessagingSetReceiveMode:

            break;

        // Immediate Server Repost - but not multiple completion enabled

        case EMobileSmsMessagingReceiveMessage:

            ret = KReqModeRePostImmediately;

            break;

        // Multiple Completion Services with Immediate Server Repost

        case EMobileSmsMessagingNotifyReceiveModeChange:

        case EMobileSmsMessagingNotifyMoSmsBearerChange:

        case EMobileSmsMessagingNotifySmspListChange:

            ret = KReqModeMultipleCompletionEnabled | 

                KReqModeRePostImmediately;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return ret;

    }

//---------------------------------------------------------------------------- 

// CMmSmsTsy::NumberOfSlotsL 

// When the ETel server discovers that a request is "repost 

// immediately" it will ask the TSY how big a buffer it wants. 

// NumberOfSlotsL Returns number of slots to be used for given requests

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

TInt CMmSmsTsy::NumberOfSlotsL( 

    const TInt aIpc )     

    {

    TInt numberOfSlots = 1;

    switch ( aIpc )

        {

        case EMobileSmsMessagingReceiveMessage:

            numberOfSlots = KMmSmsMessagingReceiveMessageSlots;

            break; 

        // It is safer that normal notification trigger value is three

        // => Slotlimits are defined according to the requirements of

        // environment, five for messagereception and three for normal

        // notifications

        case EMobileSmsMessagingNotifyReceiveModeChange:

            numberOfSlots = KMmSmsMessagingNotifyReceiveModeChangeSlots;

            break; 

        case EMobileSmsMessagingNotifyMoSmsBearerChange:

            numberOfSlots = KMmSmsMessagingNotifyMoSmsBearerChangeSlots;

            break; 

        case EMobileSmsMessagingNotifySmspListChange:

            numberOfSlots = KMmSmsMessagingNotifySmspListChangeSlots;

            break; 

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

//---------------------------------------------------------------------------- 

// CMmSmsTsy::CancelService 

// CancelService is called by the server when it is 

// "cleaning-up" any still outstanding asynchronous requests before closing 

// a client's sub-session. This will happen if a client closes its R-class 

// handle without cancelling outstanding asynchronous requests on   

// (other items were commented in a header).

// --------------------------------------------------------------------------- 

//

TInt CMmSmsTsy::CancelService( 

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobileSmsMessagingSetReceiveMode:

            ret = SetReceiveModeCancel( aTsyReqHandle );

            break;

        case EMobileSmsMessagingNotifyReceiveModeChange: