// 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 "cmmenstoretsy.h"

#include "cmmtsyreqhandlestore.h"

#include "CMmPrivateUtility.h"

#include "MmTsy_numberOfSlots.h"

#include "MmTsy_timeoutdefs.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

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

CMmENStoreTsy::CMmENStoreTsy()

    {

    }

void CMmENStoreTsy::ConstructL()

    {

#ifdef REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this,

        iMmPhone,

        KMmTsyNumOfENStoreRequests,

        iStorageReqHandles );

#else

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        KMmTsyNumOfENStoreRequests,

        iStorageReqHandles );

#endif

    // Create GSM ENStore objects

    iMmENStoreGsmExt = static_cast<CMmENStoreExtInterface*>(

        CMmENStoreGsmExt::NewL( this ) );

    // Set mode GSM

    iMmENStoreExtInterface = iMmENStoreGsmExt;

    // Construct ReadAllArray

    iENStoreReadAllArray =

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

    //register conference call tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject( 

        CMmMessageManagerBase::EENStoreTsy, this );

    }

CMmENStoreTsy* CMmENStoreTsy::NewL(

    CMmPhoneTsy* aMmPhone )

    {

    // Create EN store

    CMmENStoreTsy* aMmENStoreTsy = new( ELeave ) CMmENStoreTsy();

    CleanupClosePushL( *aMmENStoreTsy );

    // Set MM Phone and phonet sender pointers

    aMmENStoreTsy->iMmPhone = aMmPhone;

    // Call construct

    aMmENStoreTsy->ConstructL();

    CleanupStack::Pop();

    return aMmENStoreTsy;

    }

CMmENStoreTsy::~CMmENStoreTsy()

    {

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

    if (iMmPhone )

        {

        // deregister tsy object from message manager

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

        }

    // Delete TSY request handle store if it exist

    if ( NULL != iTsyReqHandleStore )

        {

        delete iTsyReqHandleStore;

        iTsyReqHandleStore = NULL;

        }

    // Delete ENStoreGsmExt

    delete iMmENStoreGsmExt;

    iMmENStoreGsmExt = NULL;

    // Delete ENStoreReadAll array

    iENStoreReadAllArray->ResetAndDestroy();

    delete iENStoreReadAllArray;

    iENStoreReadAllArray = NULL;

    iReadENStoreEntryPtr = 0;

    iENStoreInfoChanged = 0;

    iNotifyENStoreEventPtr = 0;

    iNotifyENStoreEventIndexPtr = 0;

    iReadAllBufSizePtr = 0;

    iMmPhone = 0;

    iMmENStoreExtInterface = 0;

    iTsyReqHandleStore = 0;

    }

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

// CMmENStoreTsy::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 CMmENStoreTsy::Init()

    {

    }

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

// CMmENStoreTsy::OpenNewObjectByNameL

// This method opens extendable sub-sessions.

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

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

//

CTelObject* CMmENStoreTsy::OpenNewObjectByNameL(

    const TDesC& )

    {

    // Not supported

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmENStoreTsy::OpenNewObjectL

// This method opens extendable sub-sessions.

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

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

//

CTelObject* CMmENStoreTsy::OpenNewObjectL(

    TDes& )

    {

    // Not supported

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmENStoreTsy::ReqModeL

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

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

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

//

CTelObject::TReqMode CMmENStoreTsy::ReqModeL(

    const TInt aIpc )

    {

    CTelObject::TReqMode ret = 0;

    // Match the request IPC

    switch ( aIpc )

        {

        // Non Flow controlled services

        case EMobilePhoneStoreReadAllPhase2:

            break;

        // Flow Controlled Services

        case EMobilePhoneStoreRead:

        case EMobilePhoneStoreWrite:

        case EMobilePhoneStoreDelete:

        case EMobilePhoneStoreDeleteAll:

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreGetInfo:

            ret = KReqModeFlowControlObeyed;

            break;

        // Multiple Completion Services with Immediate Server Repost

        // (Usually Notifications)

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

            break;

        // Cancel Requests

        // Listed here just for reference

        // case EMobilePhoneStoreGetInfoCancel:

        // case EMobilePhoneStoreReadCancel:

        // case EMobilePhoneStoreWriteCancel:

        // case EMobilePhoneStoreDeleteCancel:

        // case EMobilePhoneStoreDeleteAllCancel:

        // case EMobilePhoneStoreReadAllCancel:

        // case EMobilePhoneStoreNotifyStoreEventCancel:

        default:

            User::Leave( KErrNotSupported );

        }

    return ret;

    }

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

// CMmENStoreTsy::RegisterNotification

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

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

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

//

TInt CMmENStoreTsy::RegisterNotification(

    const TInt aIpc )

    {

    // Initalize ret value

    TInt ret( KErrNotSupported );

    // Match the request IPC

    switch ( aIpc )

        {

        // Not supported, but for possible future use

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KErrNone;

            break;

        default:

            // Unknown or invalid IPC.

            // ret already initialized KErrNotSupported,

            // do nothing

            break;

        }

    return ret;

    }

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

// CMmENStoreTsy::DeregisterNotification

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

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

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

//

TInt CMmENStoreTsy::DeregisterNotification(

    const TInt aIpc )

    {

    // Initalize ret value

    TInt ret( KErrNotSupported );

    // Match the request IPC

    switch ( aIpc )

        {

        // Not supported, but for possible future use

        case EMobilePhoneStoreNotifyStoreEvent:

            ret = KErrNone;

            break;

        default:

            // Unknown or invalid IPC.

            // ret already initialized KErrNotSupported,

            // do nothing

            break;

        }

    return ret;

    }

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

// CMmENStoreTsy::NumberOfSlotsL

// To ask the TSY how big buffer it wants.

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

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

//

TInt CMmENStoreTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    // Initialize number of slots to one

    TInt numberOfSlots = 1;

    // Match IPC

    switch ( aIpc )

        {

        // Not supported, but for possible future use

        case EMobilePhoneStoreNotifyStoreEvent:

            numberOfSlots = KMmENStoreNotifyStoreEventSlots;

            break;

        default:

            // Unknown or invalid EN storage IPC

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmENStoreTsy::ExtFunc

// Handling of extended requests.

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

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

//

TInt CMmENStoreTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    // Initialize ret and trap error

    TInt ret = KErrNone;

    TInt trapError = KErrNone;

    // Reset last tsy request type

    iReqHandleType = EMultimodeENStoreReqHandleUnknown;

    // Trap and call function that dispatches function requests

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

    // Check was there an error

    if ( trapError != KErrNone )

        {

        // Complete with error if trap error

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( ret != KErrNone )

        {

        // Complete with error if return value error

        ReqCompleted( aTsyReqHandle, ret );

        }

    // Save request handle

    if ( EMultimodeENStoreReqHandleUnknown != iReqHandleType )

        {

#ifdef REQHANDLE_TIMER

        SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

#endif

        }

    return KErrNone;

    }

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

// CMmENStoreTsy::DoExtFuncL

// Dispatches extension function requests.

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

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

//

TInt CMmENStoreTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    // Initialize return value

    TInt ret( KErrNotSupported );

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    switch ( aIpc )

        {

        case EMobilePhoneStoreRead:

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

            break;

        case EMobilePhoneStoreGetInfo:

            ret = GetInfo(

                REINTERPRET_CAST( RMobilePhoneStore::TMobilePhoneStoreInfoV1*,

                dataPtr ) );

            break;

        case EMobilePhoneStoreReadAllPhase1:

            ret = ReadAllPhase1( aTsyReqHandle,

                REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ),

                REINTERPRET_CAST( TInt*, dataPtr2 ) );

            break;

        case EMobilePhoneStoreReadAllPhase2:

            ret = ReadAllPhase2( aTsyReqHandle,

                REINTERPRET_CAST( RMobilePhone::TClientId*, dataPtr ),

                aPackage.Des2n() );

            break;

        // Not supported functions completes here

        // EMobilePhoneStoreWrite

        // EMobilePhoneStoreDelete

        // EMobilePhoneStoreDeleteAll

        // EMobilePhoneStoreNotifyStoreEvent

        default:

            // Do nothing, ret already set KErrNotSupported

            break;

        }

    return ret;

    }

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

// CMmENStoreTsy::CancelService

// To cancel any extension requests.

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

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

//

TInt CMmENStoreTsy::CancelService(

    const TInt aIpc,

    const TTsyReqHandle aTsyReqHandle )

    {

    // Initialize return value

    TInt ret( KErrGeneral );

    // Match cancel request using IPC

    switch ( aIpc )

        {

        case EMobilePhoneStoreGetInfo:

            ret = GetInfoCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreRead:

            ret = ReadCancel( aTsyReqHandle );

            break;

        case EMobilePhoneStoreReadAllPhase1:

        case EMobilePhoneStoreReadAllPhase2:

            ret = ReadAllCancel( aTsyReqHandle );

            break;

        // Not possible to call cancel functions below because

        // request function is not supported, and returns immediately.

        // these functions will never even called. Added here just to

        // possible future purpose.

        // case EMobilePhoneStoreWrite:

        // case EMobilePhoneStoreDelete:

        // case EMobilePhoneStoreDeleteAll:

        // case EMobilePhoneStoreNotifyStoreEvent:

        default:

            // Do nothing, ret initialized KErrGeneral

            break;

        }

    return ret;

    }

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

// CMmENStoreTsy::Read

// Read one entry from EN store.

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

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

//

TInt CMmENStoreTsy::Read(

    const TTsyReqHandle aTsyReqHandle,

    TDes8* aEntry )

    {

    TInt ret( KErrArgument );

    // Unpack entry parameters

    RMobileENStore::TMobileENEntryV1Pckg* entryPckg = REINTERPRET_CAST

        ( RMobileENStore::TMobileENEntryV1Pckg*, aEntry );

    RMobileENStore::TMobileENEntryV1& entry = ( *entryPckg )();

    // Check that client uses valid location index

    if ( 0 < entry.iIndex )

        {

        // Forward request to GSM Extension

        ret = iMmENStoreExtInterface->Read( 

            EMmTsyENStoreReadIPC, entry.iIndex );        

        }

    // ISI message construction failed or phonet sender returned error

    if ( KErrNone != ret )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

    else

        {

        // Save tsy req handle type

        iReqHandleType = EMultimodeENStoreRead;

        // Set internal EN entry pointer

        iReadENStoreEntryPtr = aEntry;        

        }

    return KErrNone;

    }

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

// CMmENStoreTsy::CompleteRead

// Complete read one entry from EN store

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

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

//

void CMmENStoreTsy::CompleteRead(

    TInt aResult,

    CMmDataPackage* aDataPackage )

    {

    // Reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

        EMultimodeENStoreRead );

    // Check that request handle was valid

    if ( EMultimodeENStoreReqHandleUnknown != reqHandle )

        {

        if ( KErrNone == aResult )

            {

            // Response information

            TENStoreResponse* enStoreResp = NULL;

            //unpack data

            if ( aDataPackage )

                {

                aDataPackage->UnPackData( &enStoreResp );

                }

            // Get entry

            RMobileENStore::TMobileENEntryV1Pckg* entryPckg =

                REINTERPRET_CAST( RMobileENStore::TMobileENEntryV1Pckg*,

                iReadENStoreEntryPtr );

            RMobileENStore::TMobileENEntryV1& entry = ( *entryPckg )();

            // Fill TMobileENEntryV1 entry

            // OBS! iCountryCode, iIdentity

            // iAlphaId cannot be filled, no info from SIM Server

            entry.iNetworkSpecific = EFalse;

            entry.iMode = RMobilePhone::ENetworkModeUnknown;

            if ( &enStoreResp )

                {

                entry.iNumber.Copy( enStoreResp->iECCNumber );

                entry.iIndex = enStoreResp->iLocation;

                }

            //Complete request to success

            ReqCompleted( reqHandle, KErrNone );