* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

#include "cmmmessagerouter.h"

const TUint8 KAnrOffsetNumLength = 1;  // refer from 3GPP TS 31.102 document

const TUint8 KAnrOffsetNumber = 2;

const TUint8 KMinLengthEfAnr = 15;

const TUint8 KMaxEmptyPatternBuf = 243;

            CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

            CMmUiccMessHandler* aUiccMessHandler,

            const CMmDataPackage* aDataPackage,

            TInt aIpc

    if( ( EMmTsyONStoreReadSizeIPC != aIpc )&&

        ( EMmTsyONStoreWriteSizeIPC != aIpc ) )

        {

        TName phonebookTypeName;

        const CPhoneBookDataPackage* phoneBookData =

            static_cast<const CPhoneBookDataPackage*>( aDataPackage );

        phoneBookData->GetPhoneBookName( phonebookTypeName );

        // Store phoneBook name 

        mmPhoneBookOperationRead3g_adn->iPhoneBookTypeName = phonebookTypeName;

        }

    mmPhoneBookOperationRead3g_adn->iMmPhoneBookStoreMessHandler =

        aMmPhoneBookStoreMessHandler;

    mmPhoneBookOperationRead3g_adn->iMmUiccMessHandler = aUiccMessHandler;

    mmPhoneBookOperationRead3g_adn->ConstructL();

    iLocationSearch = EFalse;

    iCurrentType1Ef = 0;

    iCurrentType2Ef = 0;

    iLocationSearch = EFalse;

    iNumOfEntriesFilled = 0;

    iNumOfEntriesToRead = 0;

    iIndexToRead = 0;

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

// CMmPhoneBookOperationRead3g_adn::UICCCreateReq

// Create request to read Entry

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

//

TInt CMmPhoneBookOperationRead3g_adn::UICCCreateReq

    (

    TInt aIpc,

    const CMmDataPackage* aDataPackage,

    TUint8 aTransId

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::UICCCreateReq");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONREAD3G_ADN_UICCCREATEREQ, "CMmPhoneBookOperationRead3g_adn::UICCCreateReq" );

    TInt ret( KErrNotSupported );

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

    iSavedIPCForComplete = aIpc;

    // Convert Phone Book name to file id

    iExtFileId = UICC_ILLEGAL_FILE_ID;

    iFileId = ConvertToPBfileId(

                            iPhoneBookTypeName,

                            iExtFileId,

                            iMmUiccMessHandler->GetCardType() );

    iArrayIndex = ConvertToConfArrayIndex( iFileId );

    switch( aIpc )

        {

        case EMmTsyONStoreReadIPC:

        case EMmTsyONStoreReadEntryIPC:

            {

            iFileId = PB_MSISDN_FID;

            iExtFileId = PB_EXT5_FID;

            iArrayIndex = EPhonebookTypeMSISDN;

            // Unpack index to be read

            aDataPackage->UnPackData( iIndexToRead );

            ret = USimPbReqRead( iIndexToRead, aTransId );

            break;

            }

        case EMmTsyPhoneBookStoreReadIPC:

            {

            CArrayPtrSeg<CPhoneBookStoreEntry>* prtToReadEntriesArray;

            RMobilePhoneBookStore::TPBIndexAndNumEntries* ptrToIndexAndEntries;

            phoneBookData->UnPackData(

                ptrToIndexAndEntries,

                prtToReadEntriesArray );

            if ( prtToReadEntriesArray && ptrToIndexAndEntries )

                {

                iPhoneBookStoreCacheArray = prtToReadEntriesArray;

                iNumOfEntriesToRead = ptrToIndexAndEntries->iNumSlots;

                iNumOfEntriesFilled = 0;

                iIndexToRead = ptrToIndexAndEntries->iIndex;

                if( PB_ADN_FID == iFileId )

                    {

                    // handle for ADN 3g phoneBook

                    ret = UICCHandleData3gADNReadReq( aDataPackage,

                                                      aTransId );

                    }

                else

                    {

                    ret = USimPbReqRead( iIndexToRead, aTransId );

                    }

                }

            break;

            }

        case EMmTsyONStoreReadSizeIPC:

        case EMmTsyONStoreWriteSizeIPC:

            {

            ret = USimReadWriteSizeReq( aTransId );

            break;

            }

        default:

            {

            // Nothing to do here

TFLOGSTRING2("TSY: CMmPhoneBookOperationRead3g_adn::UICCCreateReq - Unknown IPC: %d", aIpc);

OstTrace1( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONREAD3G_ADN_UICCCREATEREQ, "CMmPhoneBookOperationRead3g_adn::UICCCreateReq - UnKnown Ipc : %d", aIpc );

            break;

            }

        } // switch-case

    return ret;

    }

         const CMmDataPackage* aDataPackage,

         TUint8 aTransId         

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::UICCHandleData3gADNReadReq");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONREAD3G_ADN_UICCHANDLEDATA3GADNREADREQ, "CMmPhoneBookOperationRead3g_adn::UICCHandleData3gADNReadReq" );

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

    CArrayPtrSeg<CPhoneBookStoreEntry>* prtToReadEntriesArray;

    RMobilePhoneBookStore::TPBIndexAndNumEntries* ptrToIndexAndEntries;

    phoneBookData->UnPackData(

        ptrToIndexAndEntries,

        prtToReadEntriesArray );

    if ( prtToReadEntriesArray && ptrToIndexAndEntries )

        {

        iPhoneBookStoreCacheArray = prtToReadEntriesArray;

        iNumOfEntriesToRead = ptrToIndexAndEntries->iNumSlots;

        iNumOfEntriesFilled = 0;

        iIndexToRead = ptrToIndexAndEntries->iIndex;

        if( ( iIndexToRead <= iMmPhoneBookStoreMessHandler->

                         iPBStoreConf[EPhonebookTypeAdn].iNoOfRecords ) &&

            ( 0 < iIndexToRead ) )

            {

            ret = iMmPhoneBookStoreMessHandler->GetPBRRecordNum( iIndexToRead, 

                                                                 iCurrentPBRRecordNo);

            }

        else

            {

            // Start Reading from first location , 1st PBR Record

            iCurrentPBRRecordNo = 1;

            }

        if( KErrNone == ret )

            {

            ret = UiccReadEfRecordReq(

                         aTransId,

                         PB_PBR_FID,

                         UICC_SFI_NOT_PRESENT,

                         iCurrentPBRRecordNo );

            }

        }

    return ret;

    }

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

// CMmPhoneBookOperationRead3g_adn::UiccReadEfRecordReq

// Reads record from EFpbr

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

//

TInt CMmPhoneBookOperationRead3g_adn::UiccReadEfRecordReq( 

    const TInt aTraId, 

    const TUint16 aFileId, 

    const TUint8 aFileIdSfi,

    const TUint8 aRecordNo )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::UiccReadEfRecordReq");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONREAD3G_ADN_UICCREADEFRECORDREQ, "CMmPhoneBookOperationRead3g_adn::UiccReadEfRecordReq" );

    TUiccReadLinearFixed params;

    params.messHandlerPtr =

             static_cast<MUiccOperationBase*>( iMmPhoneBookStoreMessHandler );

    params.fileId = aFileId;

    params.fileIdSfi = aFileIdSfi;

    params.serviceType = UICC_APPL_READ_LINEAR_FIXED;

    params.record = aRecordNo;

    params.filePath.Append( static_cast<TUint8>( MF_FILE >> 8 ));

    params.filePath.Append( static_cast<TUint8>( MF_FILE ));

    params.filePath.Append( static_cast<TUint8>( APPL_FILE_ID >> 8 ));

    params.filePath.Append( static_cast<TUint8>( APPL_FILE_ID ));

    params.filePath.Append( static_cast<TUint8>( DF_PHONEBOOK >> 8 ));

    params.filePath.Append( static_cast<TUint8>( DF_PHONEBOOK ));

    params.trId = static_cast<TUiccTrId>( aTraId );

    return iMmPhoneBookStoreMessHandler->UiccMessHandler()->

                                          CreateUiccApplCmdReq( params );

    }

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

// CMmPhoneBookOperationRead::HandleUICCPbRespL

// Separate request

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

//

TBool CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL

    (

    TInt aStatus,

    TUint8 /*aDetails*/,

    const TDesC8 &aFileData,

    TInt aTransId

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONREAD3G_ADN_HANDLEUICCPBRESPL, "CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL" );

    TBool completed( EFalse );

    TInt ret( KErrNone );

    // Handle possible error case all PhoneBooks extcept Adn

    if ( UICC_STATUS_OK != aStatus )

        {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL-Unsuccessfully completed by UICC");

OstTrace0( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONREAD3G_ADN_HANDLEUICCPBRESPL, "CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL - Unsuccessfully completed by UICC" );

        ret = CMmStaticUtility::UICCCSCauseToEpocError(aStatus );

        }

    switch( iSavedIPCForComplete )

        {

        case EMmTsyPhoneBookStoreReadIPC:

        case EMmTsyONStoreReadIPC:

        case EMmTsyONStoreReadEntryIPC:

            {

            if( PB_ADN_FID == iFileId )

                {

                completed = HandleUICC3gADNRespL( aStatus,

                                                  aFileData,

                                                  aTransId );

                }

            else

                {

                completed = USimPbReadRespL( ret, 

                                    aTransId,

                                    aFileData );

                }

            break;

            }

        case EMmTsyONStoreReadSizeIPC:

        case EMmTsyONStoreWriteSizeIPC:

            {

            completed = USimReadWriteSizeResp( aFileData, ret );

            break;

            }

        default:

            {

            // Nothing to do here

TFLOGSTRING2("TSY: CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL - Unknown IPC: %d", iSavedIPCForComplete);

OstTrace1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONREAD3G_ADN_HANDLEUICCPBRESPL, "CMmPhoneBookOperationRead3g_adn::HandleUICCPbRespL - UnKnown Ipc : =%d", iSavedIPCForComplete );

            break;

            }

        }

    return completed;

    }

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

// CMmPhoneBookOperationRead3g_adn::HandleUICC3gADNRespL

// HAndles Response for ADN phoneBook

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

//

TBool CMmPhoneBookOperationRead3g_adn::HandleUICC3gADNRespL

    (

    const TInt aStatus,

    const TDesC8 &aFileData,

    const TInt aTransId

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::HandleUICC3gADNRespL");

OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONREAD3G_ADN_UICCHANDLEDATA3GADNREADREQ, "CMmPhoneBookOperationRead3g_adn::UICCHandleData3gADNReadReq" );

    TBool completed ( EFalse );

    TInt ret(KErrNone);

    switch( iCurrentReadPhase )

        {

        case EPBReadPhase_PBR_Read_Entry:

            {

            ret = UiccReadEfPbrRecordResp( aStatus, 

                                           aFileData, 

                                           aTransId );

            break;

            }

        case EPBReadPhase_Read_Type1_Entry:

            {

            ret = UiccReadEfType1RespL( aStatus, 

                                       aTransId,

                                       aFileData );

            break;

            }

        case EPBReadPhase_Read_Type2_Entry:

            {

            ret = UiccReadEfType2RespL( aStatus, 

                                       aTransId,

                                       aFileData );

            break;

            }

        case EPBReadPhase_Read_type3_Entry:

            {

            TUint8 fileTag;

            if( iType2OperationOngoing )

                {

                fileTag = iType2FileArray[iCurrentType2Ef].tagValue;

                }

            else

                {

                fileTag = iType1FileArray[iCurrentType1Ef].tagValue;

                }

            ret = UiccReadEfType3RespL( aStatus, 

                                       aTransId,

                                       fileTag,

                                       aFileData );

            break;

            }

        default:

            {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead3g_adn::HandleUICC3gADNRespL - default branch ");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONREAD3G_ADN_HANDLEUICC3GADNRESPL, "CMmPhoneBookOperationRead3g_adn::HandleUICC3gADNRespL - default branch " );

            break;

            }

        }

    if( ( EPB_3G_ADN_Read_Phase_complete == iCurrentReadPhase ) &&

        ( 0 != iNumOfEntriesToRead ) &&

        ( KErrNone == ret ) )

        iIndexToRead++;

        iCurrentEfEntryIndex++;

        // Calculate The PBR Record Number needs to be read

        // get the Max no of Entries in one PBR record

        TInt maxNoOfEntry( iMmPhoneBookStoreMessHandler->

                iPBStoreConf[EPhonebookTypeAdn].iNoOfRecords  );

        TInt maxNoOfPbrRec( iMmPhoneBookStoreMessHandler->

                iPBStoreConf[EPhonebookTypeAdn].iPBRNoOfRecords );

        if( iIndexToRead > ( iCurrentPBRRecordNo * ( maxNoOfEntry/maxNoOfPbrRec ) ) )

            {

            // Read Next PBR Record 

            iCurrentPBRRecordNo++;

            if( iCurrentPBRRecordNo <= maxNoOfPbrRec )

                {

                // Reset all Buffers

                iType1FileArray.Reset();

                iType2FileArray.Reset();

                iType3FileArray.Reset();