/*

* 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 <etelmmerr.h>      // For error code

#include <ctsy/serviceapi/gsmerror.h>       // For error code

#include "tsylogger.h"

#include "cmmmessagerouter.h"

#include "cmmphonebookoperationwrite.h"

#include "cmmphonebookalphastring.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmphonebookoperationwritetraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

const TUint8 KOwnNumberTextSize = 20;

const TUint8 KMaxMobileTelNumberSize = 100;

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

    // None

// LOCAL FUNCTION PROTOTYPES

    // None

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

    // None

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

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

// CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite

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

// might leave.

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

//

CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite()

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite");

    iPhoneBookEntry = NULL;

    }

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

// CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite

// C++ destructor.

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

//

CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite()

    {

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

    }

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

// CMmPhoneBookOperationWrite::NewL

// Creates a new CMmPhonebookOperationWrite object instance.

// Two-phased constructor.

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

CMmPhoneBookOperationWrite* CMmPhoneBookOperationWrite::NewL(

    CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

    CMmUiccMessHandler* aUiccMessHandler,

    const CMmDataPackage* aDataPackage,

    TInt aIpc ) // Data

    {

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

    TName phonebookTypeName;

    CMmPhoneBookOperationWrite* mmPhoneBookOperationWrite =

        new( ELeave ) CMmPhoneBookOperationWrite();

    if( ( EMmTsyONStoreWriteIPC != aIpc )&&

        ( EMmTsyONStoreWriteEntryIPC != aIpc ) )

        {

        TName phonebookTypeName;

        const CPhoneBookDataPackage* phoneBookData =

            static_cast<const CPhoneBookDataPackage*>( aDataPackage );

        phoneBookData->GetPhoneBookName( phonebookTypeName );

        // Store phonebook name 

        mmPhoneBookOperationWrite->iPhoneBookTypeName = phonebookTypeName;

        }

    mmPhoneBookOperationWrite->iMmPhoneBookStoreMessHandler =

        aMmPhoneBookStoreMessHandler;

    mmPhoneBookOperationWrite->iMmUiccMessHandler = aUiccMessHandler;

    return mmPhoneBookOperationWrite;

    }

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

// CMmPhoneBookOperationWrite::ConstructL

// Initialises object attributes.

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

//

void CMmPhoneBookOperationWrite::ConstructL()

    {

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

    }

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

// TInt CMmPhoneBookOperationWrite::CreateReq

// Separate request

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

//

TInt CMmPhoneBookOperationWrite::UICCCreateReq

        (

        TInt aIpc,

        const CMmDataPackage* aDataPackage,

        TUint8 aTransId

        )

    {

TFLOGSTRING2("TSY: CMmPhoneBookOperationWrite::UICCCreateReq Ipc: %d", aIpc);

    TInt ret (KErrNotSupported);

    iSavedIpc = aIpc;

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

        switch( aIpc )

            {

            case EMmTsyPhoneBookStoreWriteIPC:

                {

                TInt16 index( 0 );

                // Store Entry to the operation which needs to be write in SIM

                phoneBookData->UnPackData( index, iPhoneBookEntry );

                if ( iPhoneBookEntry )

                    {

                    // get the index Number needs to be write

                    iPhoneBookEntry->iLocation = static_cast<TUint16>( index );

                    // Convert Phone Book name to file id

                    iFileId = ConvertToPBfileId( 

                                         iPhoneBookTypeName,

                                         iExtFileId,

                                         iMmUiccMessHandler->GetCardType() );

                    iArrayIndex = ConvertToConfArrayIndex( iFileId );

                    ret = UiccPbReqWriteL( aTransId, index, *iPhoneBookEntry );

                    }

                break;

                }

            case EMmTsyONStoreWriteEntryIPC:

                {

                iFileId = PB_MSISDN_FID;

                iExtFileId = PB_EXT1_FID;

                iArrayIndex = EPhonebookTypeMSISDN;

                RMobileONStore::TMobileONEntryV1 entry;

                aDataPackage->UnPackData( entry );

                iPhoneBookEntry = new( ELeave ) CPhoneBookStoreEntry;

                CleanupStack::PushL( iPhoneBookEntry );

                iPhoneBookEntry->ConstructL();

                // Copy index number

                iPhoneBookEntry->iLocation = entry.iIndex;

                iPhoneBookEntry->iText = HBufC::NewL( KOwnNumberTextSize );

                // Copy name

                TPtr ptrToName ( iPhoneBookEntry->iText->Des() );

                CopyData( entry.iText,  ptrToName );

                iPhoneBookEntry->iNumber = HBufC::NewL( KMaxMobileTelNumberSize );

                // Copy Number

                TPtr ptrToNumber( iPhoneBookEntry->iNumber->Des() );

                CopyData( entry.iNumber.iTelNumber, ptrToNumber );

                CleanupStack::Pop( iPhoneBookEntry );

                // Send Request 

                ret = UiccPbReqWriteL( aTransId, entry.iIndex, *iPhoneBookEntry );

                break;

                }

            case EMmTsyONStoreWriteIPC:

                {

                iFileId = PB_MSISDN_FID;

                iExtFileId = PB_EXT1_FID;

                iArrayIndex = EPhonebookTypeMSISDN;

                TDesC8* entry = NULL;

                aDataPackage->UnPackData( entry );

                // Unpack entry param to get the location

                RMobileONStore::TMobileONEntryV1Pckg* entryPckg =

                    reinterpret_cast<RMobileONStore::TMobileONEntryV1Pckg*>( entry );

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

                iPhoneBookEntry = new( ELeave ) CPhoneBookStoreEntry;

                CleanupStack::PushL( iPhoneBookEntry );

                iPhoneBookEntry->ConstructL();

                // Copy index number

                iPhoneBookEntry->iLocation = onEntry.iIndex;

                iPhoneBookEntry->iText = HBufC::NewL( KOwnNumberTextSize );

                // Copy name

                TPtr ptrToName ( iPhoneBookEntry->iText->Des() );

                CopyData( onEntry.iText,  ptrToName );

                iPhoneBookEntry->iNumber = HBufC::NewL( KMaxMobileTelNumberSize );

                // Copy Number

                TPtr ptrToNumber( iPhoneBookEntry->iNumber->Des() );

                CopyData( onEntry.iNumber.iTelNumber, ptrToNumber );

                CleanupStack::Pop( iPhoneBookEntry );

                // Send Request 

                ret = UiccPbReqWriteL( aTransId, onEntry.iIndex, *iPhoneBookEntry );

                break;

                }

            default:

                {

TFLOGSTRING2("TSY: CMmPhoneBookOperationWrite::UICCCreateReq Unknown Ipc: %d", aIpc);

                break;

                }

            }

    return ret;

    }

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

// CMmPhoneBookOperationWrite::UiccPbReqWriteL

// Constructs an ISI-message to read entry from SIM

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

//

TInt CMmPhoneBookOperationWrite::UiccPbReqWriteL(

        TUint8 aTransId,

        TInt16 aIndex,

        CPhoneBookStoreEntry& aDataToWrite )

    {

TFLOGSTRING3("TSY: CMmPhoneBookOperationWrite::SimPbReqWriteL, aTransId:%d,index:%d", aTransId,  aIndex);

    TInt ret( KErrNone );

    if( ( PB_MBDN_FID == iFileId )&&

        ( 0 == iCurrentWritePhase ) )

        {

        iCurrentWritePhase = EPBWritePhase_Read_MBI_profile;

        // read MBDN record number from MBI first record 

        //Profile number

        ret = UiccPbReqReadMBI( aIndex, aTransId );

        }

    else

        {

        // Check for no of EXT records required for Writing this Entry

        TUint8 extRecordNo ( 0 ); 

        GetExtRecNum( extRecordNo );

        // Check if the index To read is valid

        if( ( UICC_ILLEGAL_FILE_ID != iFileId ) &&

            ( aIndex <= iMmPhoneBookStoreMessHandler->

                 iPBStoreConf[iArrayIndex].iNoOfRecords ) )

            {

            if( 0 < aIndex )

                {

                ret =  StartWriteEntryIndex( 

                        aIndex,

                        extRecordNo, 

                        aTransId, 

                        aDataToWrite );                

                }

            else

                {

                // Start Serching For first free Entry in the Stored list

                iEntryToWrite = iMmPhoneBookStoreMessHandler->

                EmptyEntryCheckInPBList( iArrayIndex );

                if( 0 < iEntryToWrite )

                    {

                    //Check if EXT records Are needed or not

                    if( 0 < extRecordNo )

                        {

                        // Start Serching for EXT records

                        // Search for free ext records 

                        iCurrentWritePhase = EPBWritePhase_Search_Ext_Entry;

                        // Send request To read First EXT record

                        iExtRecordNo = 1;

                        ret = UiccPbReqWriteReadExt(

                                iExtRecordNo,

                                aTransId );

                        }

                    else

                        {

                        // Start Writing Entry on given Index

                        // Start Writting Entry

                        iCurrentWritePhase = EPBWritePhase_Write_Entry;

                        ret = UiccPBReqWriteEntry(

                                iEntryToWrite,

                                aTransId,

                                aDataToWrite );

                        }

                    }

                else

                    {

                    // Start searching for first free Entry from SIM

                    iCurrentWritePhase = EPBWritePhase_Read_Entry;

                    iLocationSearch = ETrue;

                    iEntryToWrite = 1;

                    ret = UiccPbReqWriteRead(

                            iEntryToWrite,

                            aTransId );

                    }

                }

            }

        else

            {

            ret = KErrArgument;

            }

        }

    return ret;

    }

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

// CMmPhoneBookOperationWrite::UiccPBReqWriteEntry

// Constructs an ISI-message to Write main Entry data

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

//

TInt CMmPhoneBookOperationWrite::UiccPBReqWriteEntry( 

             TUint8 aIndex,

             TUint8 aTransId,

             CPhoneBookStoreEntry& aDataToWrite )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::UiccPBReqWriteEntry");

    TInt ret( KErrNone );

    TUiccWriteLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*> 

                               ( iMmPhoneBookStoreMessHandler );

        {

        }

    cmdParams.serviceType = UICC_APPL_UPDATE_LINEAR_FIXED;

    cmdParams.fileId = iFileId;

    cmdParams.trId = static_cast<TUiccTrId>( aTransId );

    // Check for valid record number

    if( aIndex <= iMmPhoneBookStoreMessHandler->

                     iPBStoreConf[iArrayIndex].iNoOfRecords )

        {

        cmdParams.record = aIndex;

        }

    else

        {

        ret = KErrArgument;

        }

    TBuf8<241>nameBuf;

    TPtr16 ptrToName = aDataToWrite.iText->Des();

    // Convert the Entry Name from ASCII format to UCS2

    CMmStaticUtility::ConvertUcs2ToGsmUcs2Data( ptrToName, nameBuf );

    if( nameBuf.Length() < iMmPhoneBookStoreMessHandler->

                           iPBStoreConf[iArrayIndex].iAlphaStringlength )

        {

        // Fill rest of the Bytes 

        for( TInt count = nameBuf.Length(); count < ( iMmPhoneBookStoreMessHandler->

                      iPBStoreConf[ iArrayIndex ].iAlphaStringlength ); count++ )

            {

            nameBuf.Append( KTagUnusedbyte );

            }

        }

    TBuf8<300>numberBuf;

    TPtr16 ptrToNumber = aDataToWrite.iNumber->Des();

    if( ptrToNumber.Length() > 0 )

        {

        iMmPhoneBookStoreMessHandler->ConvertToBCDFromUCS2(

                                      ptrToNumber,

                                      numberBuf,

                                      iFileId );

        }

    // Store number length

    TUint8 numLength ( numberBuf.Length() );

    if( numberBuf.Length() < UICC_EF_EXT_REC_NUM_LEN )

        {

        // fill  rest of the bytes

        for( TInt count = numberBuf.Length();

               count < UICC_EF_EXT_REC_NUM_LEN;

               count++)

            {

            numberBuf.Append( KTagUnusedbyte );

            }

        }

    TBuf8<200>fileDataWrite;

    fileDataWrite.Append( nameBuf.Mid( 0, iMmPhoneBookStoreMessHandler->

                          iPBStoreConf[ iArrayIndex ].iAlphaStringlength ) );

    fileDataWrite.Append( numLength );

    fileDataWrite.Append( numberBuf.Mid( 0, UICC_EF_EXT_REC_NUM_LEN ) );

    // Append Capability configuration byte as not used

    fileDataWrite.Append( KTagUnusedbyte );

    // Chekc for EXT Data is present or not

    if( 0 < iExtRecordArrayToBeWrite.Count() )

        {

        // Append Extension recorNo from iExtRecordArray to be write

        fileDataWrite.Append( iExtRecordArrayToBeWrite[0] );

        }

    else

        {

        // there is no EXT record

        fileDataWrite.Append( KTagUnusedbyte );

        }

    // Append 

    cmdParams.fileData.Append( fileDataWrite );

    if( KErrNone == ret )

        {

        ret = iMmPhoneBookStoreMessHandler->UiccMessHandler()->

            CreateUiccApplCmdReq( cmdParams );

TFLOGSTRING2("TSY: CreateUiccApplCmdReq returns %d", ret);

        }

    return ret;

    }

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

// CMmPhoneBookOperationWrite::UiccPbReqWriteExt

// Constructs an ISI-message to Write EXT Data 

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

//

TInt CMmPhoneBookOperationWrite::UiccPbReqWriteExt(

        TUint8 aTransId,

        TUint8 aIndex,

        CPhoneBookStoreEntry& aDataToWrite )

    {

TFLOGSTRING("TSY: CMmPhoneBookOperationWrite::UiccPbReqWriteExt");

    TInt ret( KErrNone );

    TUiccWriteLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*> 

                                ( iMmPhoneBookStoreMessHandler );

        {

        }