/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 <tisi.h>

#include <pn_const.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "cmmmessagerouter.h"

#include "cmmphonebookstoreoperationbase.h"

#include "cmmphonebookoperationcache.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmphonebookoperationcachetraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

const TUint8 KEFBasicLength   = 14;

// Extension length is 22 (11 bytes having 2 digits/byte)

const TUint8 KEFExtensionLength   = 22;

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

// ==================== LOCAL FUNCTIONS =====================================

    // None

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

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

// CMmPhoneBookOperationCache::CMmPhoneBookOperationCache

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMmPhoneBookOperationCache::CMmPhoneBookOperationCache

    (

    // None

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::CMmPhoneBookOperationCache");

    }

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

// CMmPhoneBookOperationCache::~CMmPhoneBookOperationCache

// C++ destructor.

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

//

CMmPhoneBookOperationCache::~CMmPhoneBookOperationCache

    (

    // None

    )

    {

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

    }

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

// CMmPhoneBookOperationCache::NewL

// Two-phased constructor.

// Creates a new CmmPhonebookOperatorInit object instance.

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

//

CMmPhoneBookOperationCache* CMmPhoneBookOperationCache::NewL

    (

    CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

    CMmUiccMessHandler* aUiccMessHandler,

    TInt /*aIpc*/,

    const CMmDataPackage* aDataPackage // Data

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::NewL");

    TName phonebookTypeName ;

    CMmPhoneBookOperationCache* mmPhoneBookOperationCache =

            new( ELeave ) CMmPhoneBookOperationCache();

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

    phoneBookData->GetPhoneBookName( phonebookTypeName );

    mmPhoneBookOperationCache->iPhoneBookTypeName = phonebookTypeName;

    mmPhoneBookOperationCache->iMmPhoneBookStoreMessHandler =

        aMmPhoneBookStoreMessHandler;

    mmPhoneBookOperationCache->iMmUiccMessHandler = aUiccMessHandler;

    return mmPhoneBookOperationCache;

    }

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

// CMmPhoneBookOperationCache::UiccCreateReq

// Separate request

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

//

TInt CMmPhoneBookOperationCache::UICCCreateReq

    (

    TInt aIpc,

    const CMmDataPackage* aDataPackage,

    TUint8 aTransId

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::CreateReq");

    TInt ret( KErrNotSupported );

    // Transaction ID is saved to separate EMmTsyONStoreGetInfoIPC handling

    // from other PB handling. Also it can be used for any separation purpose.

    iSavedIPC = aIpc;

    switch( aIpc )

        {

        case EMmTsyPhoneBookStoreGetInfoIPC:

            {

            iNumOfUsedSDNEntries = 0;

            iNumOfUsedVMBXEntries = 0;

            break;

            }

        case EMmTsyONStoreGetInfoIPC:

            {

            iFileId = PB_MSISDN_FID;

            iExtFileId = PB_EXT1_FID;

            iArrayIndex = EPhonebookTypeMSISDN;

            TInt recordId( 0 );

            iEXTNumberLen = 0;

            iTypeOfReading = EFileInfoRead;

            aDataPackage->UnPackData( recordId );

            ret = UiccReadApplFileInfo( PB_MSISDN_FID,

                                        recordId,

                                        aTransId );

            break;

            }

        case EMmTsyPhoneBookStoreCacheIPC:

            {

            // Convert Phone Book name to file id

            iExtFileId = UICC_ILLEGAL_FILE_ID;

            iFileId = ConvertToPBfileId( iPhoneBookTypeName, 

                                         iExtFileId,  

                                         iMmUiccMessHandler->GetCardType());

            iArrayIndex = ConvertToConfArrayIndex( iFileId );

            const CPhoneBookDataPackage* phoneBookData(

                static_cast<const CPhoneBookDataPackage*>( aDataPackage ) );

                {

                ret = KErrNone;

                iIndexToRead = 1 ; // Strat from 1st Record to read

                // Start Reading records from 1st record

                ret = USimPbReqRead( iIndexToRead, aTransId );

                }

            else

                {

                ret = KErrArgument;

                }

            break;

            }

        default:

            {

            // Nothing to do here

TFLOGSTRING2("TSY: CMmPhoneBookOperationCache::CreateReq - Unknown IPC: %d", aIpc);

            break;

            }

        }//switch-case

    return ret;

    }

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

// CMmPhoneBookOperationCache::HandleUICCPbRespL

// Handle response

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

//

TBool CMmPhoneBookOperationCache::HandleUICCPbRespL (

      TInt aStatus,

      TUint8 /*aDetails*/,

      const TDesC8 &aFileData,

      TInt aTransId )

    {

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

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONCACHE_HANDLEUICCPBRESPL,"CMmPhoneBookOperationCache::HandleUICCPbRespL" );

    TInt ret( KErrNone );

    TInt retExt( KErrNone );

    TBool complete ( EFalse );

// IF UICC Serever response is not OK

    if ( ( UICC_STATUS_OK != aStatus ) && ( !iExtensionToRead) )

        {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::HandleSimPbResp:Unsuccessfully completed by UICC");

        ret = CMmStaticUtility::UICCCSCauseToEpocError( aStatus );

        }

    if ( ( !iCancelOperation ) &&

         ( EMmTsyONStoreGetInfoIPC != iSavedIPC ) )

        {

        switch(iFileId)

            {

            case PB_ADN_FID:

            case PB_FDN_FID:

            case PB_SDN_FID:

                {

                // Start Caching for ADN Phone Book

                if(!iExtensionToRead)

                    {

                    // Check for UICC_SERVER_OK

                    if( UICC_STATUS_OK == aStatus)

                        {

                        iStoreEntry = new ( ELeave ) TPBEntry();

                        // update Entry Data

                        iStoreEntry->iEntryIndex = iIndexToRead;

                        // check if Entry is valid Entry or Empty Entry

                        TInt retval = EmptyEntryCheck(aFileData);

                        // if Entry is not empty

                        if( KErrNone == retval)

                            {

                            // Update Entry Status

                            iStoreEntry->iEntryPresent = ETrue;

                            // Seperate Entry data form UICC Server response message

                            // Case: <Data available to be filled into array>

                            iMmPhoneBookStoreMessHandler->

                            iPBStoreConf[iArrayIndex].

                            GetPBEntryFromUICCData(

                                aFileData,

                                iNumberBuf,

                                iNameBuf);

                            // Check for Is there any extension data

                            // And the Extension data record number is valid

                            // Index to read Extension file Data is Alpha string

                            // Length + 14 , minus 1 is for Array index Calculation

                            //(it starts from 0)

                            if ( 0xFF == aFileData[iMmPhoneBookStoreMessHandler->

                                         iPBStoreConf[iArrayIndex].

                                         iAlphaStringlength + 13]  )

                                {

                                // Append Entry to list

                                iMmPhoneBookStoreMessHandler->StoreEntryToPhoneBookList(

                                              iStoreEntry,

                                              iArrayIndex );

                                // the there is no extension data

                                CPhoneBookStoreEntry* phoneBookStoreMsg =

                                new( ELeave ) CPhoneBookStoreEntry;

                                CleanupStack::PushL( phoneBookStoreMsg );

                                phoneBookStoreMsg->ConstructL();

                                iMmPhoneBookStoreMessHandler->StorePhonebookEntryL(

                                    iNameBuf,

                                    iNumberBuf,

                                    *phoneBookStoreMsg,

                                    iFileId,

                                    iIndexToRead );

                                TF_ASSERT( NULL != iPhoneBookStoreCacheArray );

                                iPhoneBookStoreCacheArray->AppendL( phoneBookStoreMsg );

                                CleanupStack::Pop( phoneBookStoreMsg );

                                iNumOfEntriesFilled++;

TFLOGSTRING2("TSY: CMmPhoneBookOperationCache::HandleUICCPbRespL - Append entries into array %d",iNumOfEntriesFilled);

                                } // End of if Ext Data is not Present

                            else

                                {

                                iExtensionToRead = ETrue;

                                // Record no to be read from EXT File

                                TInt recordNo = aFileData[iMmPhoneBookStoreMessHandler->

                                               iPBStoreConf[iArrayIndex].

                                               iAlphaStringlength + 13];

                                // Append EXT record no.

                                iStoreEntry->PBEntryExtRecord.Append( recordNo );

                                retExt = USimPbReqRead( recordNo, aTransId );

                                // if while reading EXT error comes

                                //(for invalid Entry)than read next entry

                                if(( KErrNone != retExt ))

                                    {

                                    iExtensionToRead = EFalse;

                                    }

                                } // End for EXT File data present

                            } // end for case when entry is not empty

                        else

                            {

                            //Update Entry Status

                            iStoreEntry->iEntryPresent = EFalse;

                            // Reset Entry andd Append to the List

                            iMmPhoneBookStoreMessHandler->StoreEntryToPhoneBookList(

                                 iStoreEntry,

                                 iArrayIndex );

                            }

                        // to read next record

                        iIndexToRead++;

                        } // end of check for UICC status

                    } // End of without EXT File Data Case

                else  // Handling for Extension Numbers

                    {

                    if( UICC_STATUS_OK == aStatus )

                        {

                        // Check for next extension data record

                        if(0xFF != aFileData[UICC_EXT_REC_NO_OFFSET])

                            {

                            // Again Append the EXT no to Array

                            iStoreEntry->PBEntryExtRecord.Append(

                                  aFileData[UICC_EXT_REC_NO_OFFSET] );

                            // Store Number upto last byte

                            iNumberBuf.Append(aFileData.Mid(1,UICC_EF_EXT_REC_NUM_LEN ));

                            // Again Send request to read next record number

                            //and append it in number

                            retExt = USimPbReqRead(

                                aFileData[UICC_EXT_REC_NO_OFFSET], aTransId );

                            if( KErrNone != retExt)

                                {

                                iExtensionToRead = EFalse;

                                }

                            }  // end for checking next record number in EXT

                        else

                            {

                            // Append Entry to list and reset all the EXT data

                            iMmPhoneBookStoreMessHandler->StoreEntryToPhoneBookList(

                                                          iStoreEntry,

                                                          iArrayIndex );

                            // Reset Extension File record

                            iExtensionToRead = EFalse;

                            // Check for Extended Data is Addition number

                            if( 0x02 == aFileData[0])

                                {

                                // Check for length upto which no is stored

                                TInt offset = aFileData.Find(&KTagUnusedbyte,1);

                                // store Data

                                iNumberBuf.Append(aFileData.Mid(1,( offset - 1 )));

                                // the there is extension data

                                CPhoneBookStoreEntry* phoneBookStoreMsg =

                                new( ELeave ) CPhoneBookStoreEntry;

                                CleanupStack::PushL( phoneBookStoreMsg );

                                phoneBookStoreMsg->ConstructL();

                                iMmPhoneBookStoreMessHandler->StorePhonebookEntryL(

                                                              iNameBuf,

                                                              iNumberBuf,

                                                              *phoneBookStoreMsg,

                                                              iFileId,

                                                              iIndexToRead );

                                TF_ASSERT( NULL != iPhoneBookStoreCacheArray );

                                iPhoneBookStoreCacheArray->AppendL(

                                                           phoneBookStoreMsg );

                                CleanupStack::Pop( phoneBookStoreMsg );

                                iNumOfEntriesFilled++;

TFLOGSTRING2("TSY: CMmPhoneBookOperationCache::HandleUSimPbRespL - Append entries into array %d",iNumOfEntriesFilled);

                                } // end for checking Data type in EXT

                            } // end for Entry store

                        }

                    else

                        {

                        // To read next Entry

                        iExtensionToRead = EFalse;

                        }

                    } // end for EXT file handling

                break;

                } // end for ADN phone book cache

            default:

                {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::HandleUICCPbRespL. PhoneBook operation not supported ");

                break;

                }

            } // End of switch case

        // Check for next location be read when its not for EXT Data

        if( ( !iExtensionToRead ) &&( iIndexToRead <=

              iMmPhoneBookStoreMessHandler->iPBStoreConf[iArrayIndex].iNoOfRecords ) )

            {

            // Send request to read next Entry

            USimPbReqRead( iIndexToRead, aTransId );

            }

        // Complete IPC if error is there OR all Entries are read

        if( ((KErrNone != ret) ||

             ( iIndexToRead > iMmPhoneBookStoreMessHandler->

                              iPBStoreConf[iArrayIndex].iNoOfRecords ))

             && ( !iExtensionToRead ))

            {

            // Check if any entries are filled in commonTSY Array

            if( 0 == iNumOfEntriesFilled )

                {

                ret = KErrNotFound;

                }

            // Complete

            CPhoneBookDataPackage phoneBookData;

            phoneBookData.SetPhoneBookName( iPhoneBookTypeName );

            iPhoneBookStoreCacheArray = NULL;

            iMmPhoneBookStoreMessHandler->MessageRouter()->Complete(

                EMmTsyPhoneBookStoreCacheIPC,

                &phoneBookData,

                ret );

            // Set flag to indicate that we can remove this operation from array

            complete = ETrue;

            }

        }

    else if ( EMmTsyONStoreGetInfoIPC == iSavedIPC )

        {

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::HandleUICCPbRespL: Handle EMmTsyONStoreGetInfoIPC");

        complete = HandleUiccReadApplFileInfoResp( aTransId,

                                                   aStatus,

                                                   aFileData );

        }

    else

        { // Operation has been canceled

        complete = ETrue;

TFLOGSTRING("TSY: CMmPhoneBookOperationCache::HandleUICCPbRespL; operation was canceled");

        }

    return complete;

    }

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

// CMmPhoneBookOperationRead::USimPbReqRead

// Constructs Data to read entry from SIM

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

//

TInt CMmPhoneBookOperationCache::USimPbReqRead

    (

    TInt aRecordNo,

    TUint8 aTransId

    )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationRead::USimPbReqRead");

    TInt ret( KErrNone );

    TInt appFileID ( APPL_FILE_ID );   // Application File id for DFphonebook

    TUiccReadLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*>

                               ( iMmPhoneBookStoreMessHandler );