// 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 <etelmm.h>

#include "cmmsmsstoragetsy.h"

#include "cmmphonetsy.h"

#include "cmmsmstsy.h"

#include "cmmsmsextinterface.h"

#include "MmTsy_numberOfSlots.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

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

CMmSmsStorageTsy::CMmSmsStorageTsy():

    iReqHandleType(CMmSmsTsy::EMultimodeSmsReqHandleUnknown)

    {

    }

void CMmSmsStorageTsy::ConstructL()

    {

    ResetVariables();

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

    iSmsReadAllArray = new ( ELeave ) CArrayPtrFlat<CListReadAllAttempt>( 1 );

    // register sms storage tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject( 

        CMmMessageManagerBase::EPhoneStoreTsy, this );

    }

CMmSmsStorageTsy* CMmSmsStorageTsy::NewL( 

    CMmSmsTsy* aMmSmsTsy, 

    CMmPhoneTsy* aMmPhone, 

    CMmSmsExtInterface* aMmSmsExtInterface, 

    CMmTsyReqHandleStore* aMmTsyReqHandleStore )

    {

    CMmSmsStorageTsy* subsession = new ( ELeave ) CMmSmsStorageTsy();

    CleanupClosePushL( *subsession );

    subsession->iMmSmsTsy = aMmSmsTsy;

    subsession->iMmPhone = aMmPhone;

    subsession->iMmSmsExtInterface = aMmSmsExtInterface;

    subsession->iMmTsyReqHandleStore = aMmTsyReqHandleStore;

    subsession->ConstructL();

    CleanupStack::Pop(subsession);

    return subsession;  

    }

CMmSmsStorageTsy::~CMmSmsStorageTsy()

    {

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

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

        }

    if ( iSmsListArray )

        {

        delete iSmsListArray;        

        }

    iSmsListArray = NULL;

    if ( iSmsReadAllArray )

        {

        delete iSmsReadAllArray;

        }

	iSmsReadAllArray = NULL;

	// Set pointers to NULL

	iMmTsyReqHandleStore = NULL;

	iMmPhone = NULL;

	iMmSmsExtInterface = NULL;

	iGetInfoInfoPtr = NULL;

	iNotifySmsStoreEventIndexPtr = NULL;

	iReadSmsEntryPtr = NULL;

	iReadAllBufSizePtr = NULL;

	iWriteSmsEntryPtr = NULL;

	iNotifySmsStoreEventPtr = NULL;

    // Set CMmSmsTsy's SmsStoragePointer to NULL

    iMmSmsTsy->SetSmsStorageTsy( NULL );

	iMmSmsTsy = NULL;

    }

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

// CMmSmsStorageTsy::Init 

// Initialisation method

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

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

//

void CMmSmsStorageTsy::Init()

    {

    // Send request to the Domestic OS layer.

    TRAP_IGNORE( iMmPhone->MessageManager()->HandleRequestL( 

        EMobilePhoneStoreGetInfo ); );

    }

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

// CMmSmsStorageTsy::ExtFunc 

// Handle sms storage related requests that doesn't need

// trapping or call DoExtFuncL-method

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

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

//

TInt CMmSmsStorageTsy::ExtFunc( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    switch ( aIpc )

        {

        // SMS storage requests that doesn't need trapping

        case EMobilePhoneStoreReadAllPhase2:

            ret = ReadAllSmsPhase2( aTsyReqHandle, 

                REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ),

                aPackage.Des2n() );

            break;

        // SMS storage 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==CMmSmsTsy::EMultimodeSmsReqHandleUnknown, User::Invariant());

            TInt leaveCode( KErrNone );

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

                aPackage ); );

            if ( KErrNone != leaveCode )

                {

                ReqCompleted( aTsyReqHandle, leaveCode );

                }

            // save request handle

            if ( CMmSmsTsy::EMultimodeSmsReqHandleUnknown != iReqHandleType )

                {

#ifdef REQHANDLE_TIMER

                iMmSmsTsy->SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

                // Never comes here. See SetTypeOfResponse.

                iMmTsyReqHandleStore->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 = CMmSmsTsy::EMultimodeSmsReqHandleUnknown;

                }

            break;

        }

    return ret;

    }

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

// CMmSmsStorageTsy::DoExtFunc 

// Handling of sms storage related requests that needs trapping

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

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

//

TInt CMmSmsStorageTsy::DoExtFuncL( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )      

    {

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        // SMS message storage requests

        case EMobilePhoneStoreGetInfo:

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

            break;

        case EMobilePhoneStoreRead:

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

            break;

        case EMobilePhoneStoreWrite:

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

            break;

        case EMobilePhoneStoreDelete:

            ret = DeleteSmsL( aTsyReqHandle, 

                REINTERPRET_CAST( TInt*, dataPtr ) );

            break;

        case EMobilePhoneStoreDeleteAll:

            ret = DeleteAllSmsL( aTsyReqHandle );

            break;

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = NotifySmsStoreEvent( REINTERPRET_CAST( 

                RMobilePhoneStore::TMobileStoreEvent*, dataPtr ),

                REINTERPRET_CAST( TInt*, dataPtr2 ) );

            break;

        case EMobilePhoneStoreReadAllPhase1:

            ret = ReadAllSmsPhase1L( aTsyReqHandle, REINTERPRET_CAST( 

                CRetrieveMobilePhoneSmsList::TBatchRequestData*, dataPtr ), 

                REINTERPRET_CAST( TInt*, dataPtr2 ) );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmSmsStorageTsy::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 CMmSmsStorageTsy::CancelService( 

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreGetInfo:

            ret = GetInfoCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreRead:

            ret = ReadSmsCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreWrite:

        case EMobilePhoneStoreDelete:

        case EMobilePhoneStoreDeleteAll:

            ret = KErrNone;

            break;

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = NotifySmsStoreEventCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreReadAllPhase2:

            ret = ReadAllSmsCancel( aTsyReqHandle );

            break;

        default:

            ret = KErrGeneral; 

            break;

        } 

    return ret;

    }

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

// CMmSmsStorageTsy::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 CMmSmsStorageTsy::ReqModeL( 

    const TInt aIpc )

    {

    CTelObject::TReqMode ret( 0 );

    switch ( aIpc )

        {        

        // Non-flow Controlled Services

        case EMobilePhoneStoreGetInfo:

        case EMobilePhoneStoreRead:

        case EMobilePhoneStoreWrite:

        case EMobilePhoneStoreDelete:

        case EMobilePhoneStoreDeleteAll:

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreReadAllPhase2:

            break;

        // Multiple Completion Services with Immediate Server Repost

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KReqModeMultipleCompletionEnabled | 

                  KReqModeRePostImmediately;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return ret;

    }

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

// CMmSmsStorageTsy::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 CMmSmsStorageTsy::NumberOfSlotsL( 

    const TInt aIpc )

    {

    TInt numberOfSlots( 1 );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            numberOfSlots = KMmPhoneStoreNotifyStoreEventSlots;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmSmsStorageTsy::OpenNewObjectL 

// This method opens extendable sub-sessions

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

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

//

CTelObject* CMmSmsStorageTsy::OpenNewObjectL(

    TDes& /*aName*/ )     

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmSmsStorageTsy::OpenNewObjectByNameL 

// This method opens extendable sub-sessions

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

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

//

CTelObject* CMmSmsStorageTsy::OpenNewObjectByNameL( 

    const TDesC& /*aName*/ )  

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmSmsStorageTsy::RegisterNotification 

// Called when the server recognises that this notification

// is being posted for the first time on this sub-session object.

// It enables the TSY to "turn on" any regular notification messages that it 

// may receive from DOS

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

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

//

TInt CMmSmsStorageTsy::RegisterNotification( 

    const TInt aIpc )     

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KErrNone;

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmSmsStorageTsy::DeregisterNotification 

// Called when the server recognises that this notification

// will not be posted again because the last client to have 

// a handle on this sub-session object has just closed the handle.

// It enables the TSY to "turn off" any regular notification messages that 

// it may receive from the DOS

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

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

//

TInt CMmSmsStorageTsy::DeregisterNotification( 

    const TInt aIpc )

    {

    TInt ret( KErrNotSupported );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KErrNone;

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmSmsStorageTsy::GetInfoL 

// This method start getting info prosess from selected store (SIM)

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

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

//

TInt CMmSmsStorageTsy::GetInfoL( 

    const TTsyReqHandle aTsyReqHandle, 

    TDes8* aSmsStoreInfoPckg )

    {

    TInt ret = KErrArgument;

    if (aSmsStoreInfoPckg)

    	{

    	RMobilePhoneStore::TMobilePhoneStoreInfoV1 temp;

		TPckg<RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg> tempPckg(temp);

		TInt expectedLength = tempPckg.MaxLength();

		TInt paramLength = aSmsStoreInfoPckg->MaxLength();

		if (paramLength >= expectedLength)

			{    

		    TTsyReqHandle getInfoHandle = iMmTsyReqHandleStore->GetTsyReqHandle( 

		        CMmSmsTsy::EMultimodeSmsGetInfo );

		    if ( CMmSmsTsy::EMultimodeSmsReqHandleUnknown < getInfoHandle )

		        {

		        // The request is already in processing because of previous request.

		        // Complete request with status value informing the client about 

		        // the situation.

		        ReqCompleted( aTsyReqHandle, KErrServerBusy );

		        }

		    else

		        {

		        iGetInfoInfoPtr = aSmsStoreInfoPckg;

		        // allow for EMobilePhoneStoreGetInfo immediate completion

#ifdef REQHANDLE_TIMER

		        iMmSmsTsy->SetTypeOfResponse( CMmSmsTsy::EMultimodeSmsGetInfo, 

		            aTsyReqHandle );

#else

		            // Never comes here. See SetTypeOfResponse.

		            iMmTsyReqHandleStore->SetTsyReqHandle( 

		                CMmSmsTsy::EMultimodeSmsGetInfo, aTsyReqHandle );

#endif // REQHANDLE_TIMER

		        // Send request to the Domestic OS layer.

		        ret = iMmPhone->MessageManager()->HandleRequestL( 

		            EMobilePhoneStoreGetInfo );

		        // dos layer returned with error and didn't complete request

		        if ( ret != KErrNone && iMmTsyReqHandleStore->ResetTsyReqHandle(

		            CMmSmsTsy::EMultimodeSmsGetInfo) )

		            {

		            ReqCompleted( aTsyReqHandle, ret );

		            }

		        }

			ret = KErrNone;

			}

    	}

    return ret;

    }

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

// CMmSmsStorageTsy::GetInfoCancel 

// This method cancel GetInfo request

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

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

//

TInt CMmSmsStorageTsy::GetInfoCancel( 

    const TTsyReqHandle aTsyReqHandle )

    {

    iMmTsyReqHandleStore->ResetTsyReqHandle( 

        CMmSmsTsy::EMultimodeSmsGetInfo );

    ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmSmsStorageTsy::CompleteGetInfo 

// Complete Clients GetInfo request

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

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

//

void CMmSmsStorageTsy::CompleteGetInfo( 

    TInt aResult, 

    CMmDataPackage* aDataPackage )

    {

    TUint8 totalEntries( 0 );

    TInt usedEntries( 0 );

    TTsyReqHandle reqHandle = iMmTsyReqHandleStore->ResetTsyReqHandle(