// Copyright (c) 2006-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:

//

//  INCLUDE FILES

#include "cmmonstoretsy.h"

#include "cmmtsyreqhandlestore.h"

#include "CMmPrivateUtility.h"

#include "MmTsy_numberOfSlots.h"

#include "MmTsy_timeoutdefs.h"

#include "cmmmessagemanagerbase.h"

#include "cmmpblist.h"

#include "cmmphonebookstoretsy.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

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

CMmONStoreTsy::CMmONStoreTsy()

    {

    }

void CMmONStoreTsy::ConstructL()

    {

TFLOGSTRING("TSY: CMmONStoreTsy::ConstructL");

#ifdef REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone, 

        EMmTsyNumOfONStoreRequests, iStorageReqHandles );

#else // REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMmTsyNumOfONStoreRequests, iStorageReqHandles );

#endif // REQHANDLE_TIMER

    //get mode of current extension.

    RMobilePhone::TMobilePhoneNetworkMode currentMode;

    iMmPhone->GetStaticExtensionMode( &currentMode );

    // Reset phonebooktype and servicetype

    ResetVariables();

    // Create GSM ONStore objects

    iMmONStoreGsmExt = static_cast<CMmONStoreExtInterface*>(

        CMmONStoreGsmExt::NewL( this ) );

    // Set mode GSM

    iMmONStoreExtInterface = iMmONStoreGsmExt;

    //if current mode is GSM

    if ( RMobilePhone::ENetworkModeGsm == currentMode )

        {

        // Set phonebook type and servicetype

        iPhoneBookType = KSimMsisdn;  // MSISDN

        }

    // Construct ReadAllList

    iONStoreListArray = new (ELeave) CArrayFixFlat<TONStoreMsg>(1);

    // Construct ReadAllArray

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

    //register ON Store tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject( 

        CMmMessageManagerBase::EONStoreTsy, this );

    // Reset info to fill with ini values

    SetInfo();

    }

CMmONStoreTsy* CMmONStoreTsy::NewL(

    CMmPhoneTsy* aMmPhone )

    {

    CMmONStoreTsy* aMmONStoreTsy = new( ELeave ) CMmONStoreTsy();

    CleanupClosePushL( *aMmONStoreTsy );

    aMmONStoreTsy->iMmPhone = aMmPhone;

    aMmONStoreTsy->ConstructL();

    CleanupStack::Pop();

    return aMmONStoreTsy;

    }

CMmONStoreTsy::~CMmONStoreTsy()

    {

TFLOGSTRING("TSY: CMmONStoreTsy::~CMmONStoreTsy");

    if (iMmPhone )

        {

        // deregister tsy object from message manager

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

        }

    if ( NULL != iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        iTsyReqHandleStore = NULL;

        }

    // Delete ONStoreGsmExt

    delete iMmONStoreGsmExt;

    iMmONStoreGsmExt = NULL;

    // Delete TSY's internal ONStore list

    delete iONStoreListArray;

    iONStoreListArray = NULL;

    // Delete ONStoreReadAll array

    iONStoreReadAllArray->ResetAndDestroy();

    delete iONStoreReadAllArray;

    iONStoreReadAllArray = NULL;

    }

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

// CMmONStoreTsy::Init

// Initialisation method that is called from ETel Server.

// This is an initialization method for the class functionality.

// Generally initization method inits e.g. class attributes.

// In this case, this method is not needed.

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

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

//

void CMmONStoreTsy::Init()

    {

    }

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

// CMmONStoreTsy::OpenNewObjectByNameL

// This method opens extendable sub-sessions

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

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

//

CTelObject* CMmONStoreTsy::OpenNewObjectByNameL(

    const TDesC& )

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmONStoreTsy::OpenNewObjectL

// This method opens extendable sub-sessions

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

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

//

CTelObject* CMmONStoreTsy::OpenNewObjectL(

    TDes& )

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmONStoreTsy::ReqModeL

// To ask what type of flow control is used for the IPC number.

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

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

//

CTelObject::TReqMode CMmONStoreTsy::ReqModeL(

    const TInt aIpc )

    {

TFLOGSTRING2("TSY: CMmONStoreTsy::ReqModeL IPC %d", aIpc);

    CTelObject::TReqMode ret=0;

    switch ( aIpc )

        {

        // Flow Controlled Services

        case EMobilePhoneStoreRead:

        case EMobilePhoneStoreWrite:

        case EMobilePhoneStoreDelete:

        case EMobilePhoneStoreDeleteAll:

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreReadAllPhase2:

        case EMobilePhoneStoreGetInfo:

        case EMobileONStoreStoreAll:

            ret=KReqModeFlowControlObeyed;

            break;

        // Multiple Completion Services with Immediate Server Repost

        // (Usually Notifications)

        case EMobilePhoneStoreNotifyStoreEvent:

            ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

            break;

        default:

            User::Leave(KErrNotSupported);

            break;

        }

    return ret;

    }

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

// CMmONStoreTsy::RegisterNotification

// Enables the TSY to "turn on" any regular notification

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

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

//

TInt CMmONStoreTsy::RegisterNotification(

    const TInt aIpc )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            // KErrNone

            break;

        default:

            // Unknown or invalid IPC

            ret = KErrNotSupported;

        }

    return ret;

    }

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

// CMmONStoreTsy::DeregisterNotification

// Enables the TSY to "turn off" any regular notification

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

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

//

TInt CMmONStoreTsy::DeregisterNotification(

    const TInt aIpc )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            // KErrNone

            break;

        default:

            // Unknown or invalid IPC

            ret = KErrNotSupported;

        }

    return ret;

    }

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

// CMmONStoreTsy::NumberOfSlotsL

// To ask the TSY how big buffer it wants

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

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

//

TInt CMmONStoreTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    TInt numberOfSlots = 1;

    switch ( aIpc )

        {

        case EMobilePhoneStoreNotifyStoreEvent:

            numberOfSlots = KMmONStoreNotifyStoreEventSlots;

            break;

        default:

            // Unknown or invalid Phone IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmONStoreTsy::ExtFunc

// Handling of extended requests

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

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

//

TInt CMmONStoreTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

TFLOGSTRING3("TSY: CMmONStoreTsy::ExtFunc - IPC:%d Handle:%d", aIpc, aTsyReqHandle);   

    TInt ret = KErrNone;

    TInt trapError = KErrNone;

    // Reset last tsy request type

    iReqHandleType = EMultimodeONStoreReqHandleUnknown;

    TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

    if ( KErrNone != trapError )

        {

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( KErrNone != ret )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

    // Save request handle

    if ( EMultimodeONStoreReqHandleUnknown != iReqHandleType )

        {

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else // REQHANDLE_TIMER

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif // REQHANDLE_TIMER

        }

    return KErrNone;

    }

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

// CMmONStoreTsy::DoExtFuncL

// Dispatches extension function requests

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

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

//

TInt CMmONStoreTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

TFLOGSTRING3("TSY: CMmONStoreTsy::DoExtFuncL - IPC:%d Handle:%d", aIpc, aTsyReqHandle);

    TAny* dataPtr=aPackage.Ptr1();

    TAny* dataPtr2=aPackage.Ptr2();

    // Create unique transaction id

    switch (aIpc)

        {

        case EMobilePhoneStoreRead:

            return ReadL( aPackage.Des1n() );

        case EMobilePhoneStoreWrite:

            return WriteL( aTsyReqHandle, aPackage.Des1n() );

        case EMobilePhoneStoreDelete:

            return DeleteL( aTsyReqHandle,

                REINTERPRET_CAST( TInt*, dataPtr ) );

        case EMobilePhoneStoreDeleteAll:

            return DeleteAllL( aTsyReqHandle );

        case EMobilePhoneStoreGetInfo:

            return GetInfoL( aTsyReqHandle,

                REINTERPRET_CAST( RMobileONStore::TMobileONStoreInfoV1*, 

                    dataPtr ) );

        case EMobilePhoneStoreReadAllPhase1:

            return ReadAllPhase1L( aTsyReqHandle,

                REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ),

                REINTERPRET_CAST( TInt*, dataPtr2 ) );

        case EMobilePhoneStoreReadAllPhase2:

            return ReadAllPhase2( aTsyReqHandle,

                REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ), 

                aPackage.Des2n() );

        case EMobilePhoneStoreNotifyStoreEvent:

            return NotifyStoreEvent(

                REINTERPRET_CAST( RMobilePhoneStore::TMobileStoreEvent*, 

                dataPtr ), REINTERPRET_CAST( TInt*, dataPtr2 ) );

        case EMobileONStoreStoreAll:

            return StoreAllL( aTsyReqHandle,aPackage.Des1n() );

        default:

            return KErrNotSupported;

        }

    }

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

// CMmONStoreTsy::CancelService

// To cancel any extension requests

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

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

//

TInt CMmONStoreTsy::CancelService(

    const TInt aIpc,

    const TTsyReqHandle aTsyReqHandle )

    {

    switch ( aIpc )

        {

        case EMobilePhoneStoreGetInfo:

            return GetInfoCancel( aTsyReqHandle );

        case EMobilePhoneStoreRead:

            return ReadCancel( aTsyReqHandle );

        case EMobilePhoneStoreWrite:

            return WriteCancel( aTsyReqHandle );

        case EMobilePhoneStoreDelete:

            // There is no change to cancel this request, so only thing to do,

            // is let the request continue and return KErrNone.

            return KErrNone;

        case EMobilePhoneStoreDeleteAll:

            return DeleteAllCancel( aTsyReqHandle );

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreReadAllPhase2:

            return ReadAllCancel( aTsyReqHandle );

        case EMobilePhoneStoreNotifyStoreEvent:

            return NotifyStoreEventCancel( aTsyReqHandle );

        case EMobileONStoreStoreAll:

            return StoreAllCancel( aTsyReqHandle );

        default:

            return KErrGeneral;

        }

    }

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

// CMmONStoreTsy::SetActiveONStoreExtension

// Sets pointer to active extension

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

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

//

TInt CMmONStoreTsy::SetActiveONStoreExtension(

    CMmONStoreExtInterface* aMmONStoreExt )

    {

    TInt ret = KErrGeneral;

    if ( aMmONStoreExt )

        {

        iMmONStoreExtInterface = aMmONStoreExt;

        ret = KErrNone;

        }

    return ret;

    }

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

// CMmONStoreTsy::Returns a pointer to the active extension

// Sets pointer to active extension

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

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

//

CMmONStoreExtInterface* CMmONStoreTsy::ActiveONExtension()

    {

    return iMmONStoreExtInterface;

    }

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

// CMmONStoreTsy::ReadL

// Read one ON store entry using index

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

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

//

TInt CMmONStoreTsy::ReadL( TDes8* aEntry )

    {

TFLOGSTRING("TSY: CMmONStoreTsy::ReadL");

    // Initialize ret value

    TInt ret( KErrArgument );

    if( sizeof( RMobileONStore::TMobileONEntryV1 ) <= aEntry->MaxLength() )

	  	{

        // Unpack entry parameter

        RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

            REINTERPRET_CAST

            ( RMobileONStore::TMobileONEntryV1Pckg*, aEntry );

        RMobileONStore::TMobileONEntryV1& entry = ( *entryPckg )();

        // Check index

        if ( (-1) <= entry.iIndex )

            {

            // Forward request to GSM Extension

            ret = iMmONStoreExtInterface->ReadL( EMmTsyONStoreReadIPC, entry.iIndex );

            }

        if ( KErrNone == ret )

            {

            // Save entry pointer

            iReadONStoreEntryPtr = aEntry;

            // Save tsy req handle type

            iReqHandleType = EMultimodeONStoreRead;

            }

	  	}

    return ret;

    }

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

// CMmONStoreTsy::CompleteRead

// Completes reading a entry from the ONStore

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

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

//

void CMmONStoreTsy::CompleteRead(

    TInt aResult,

    CMmDataPackage* aDataPackage )

    {

TFLOGSTRING("TSY: CMmONStoreTsy::CompleteRead");

    // Response information

    TONStoreMsg* ONStoreResp = NULL;

    // unpack data if exists

    if ( aDataPackage )

        {

        //unpack data

        aDataPackage->UnPackData( ONStoreResp );

        }

    else if ( KErrNone == aResult )

        {

TFLOGSTRING("TSY: CMmONStoreTsy::CompleteRead result is KErrNone and aDataPackage is NULL!");

        aResult = KErrArgument;

        }

    // Reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

        EMultimodeONStoreRead );

    if ( EMultimodeONStoreReqHandleUnknown != reqHandle )

        {

        if ( KErrNone == aResult )