/*

* 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"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmphonebookoperationwritetraces.h"

#endif

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

// 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");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_CMMPHONEBOOKOPERATIONWRITE, "CMmPhoneBookOperationWrite::CMmPhoneBookOperationWrite" );

    iPhoneBookEntry = NULL;

    }

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

// CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite

// C++ destructor.

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

//

CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite()

    {

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

OstTrace0( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_CMMPHONEBOOKOPERATIONWRITE, "CMmPhoneBookOperationWrite::~CMmPhoneBookOperationWrite" );

    }

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

// CMmPhoneBookOperationWrite::NewL

// Creates a new CMmPhonebookOperationWrite object instance.

// Two-phased constructor.

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

CMmPhoneBookOperationWrite* CMmPhoneBookOperationWrite::NewL(

    CMmPhoneBookStoreMessHandler* aMmPhoneBookStoreMessHandler,

    CMmUiccMessHandler* aUiccMessHandler,

    {

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

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_NEWL, "CMmPhoneBookOperationWrite::NewL" );

    TName phonebookTypeName;

    CMmPhoneBookOperationWrite* mmPhoneBookOperationWrite =

        new( ELeave ) CMmPhoneBookOperationWrite();

    mmPhoneBookOperationWrite->iMmPhoneBookStoreMessHandler =

        aMmPhoneBookStoreMessHandler;

    mmPhoneBookOperationWrite->iMmUiccMessHandler = aUiccMessHandler;

    return mmPhoneBookOperationWrite;

    }

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

// CMmPhoneBookOperationWrite::ConstructL

// Initialises object attributes.

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

//

void CMmPhoneBookOperationWrite::ConstructL()

    {

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

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_CONSTRUCTL, "CMmPhoneBookOperationWrite::ConstructL" );

    }

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

// TInt CMmPhoneBookOperationWrite::CreateReq

// Separate request

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

//

TInt CMmPhoneBookOperationWrite::UICCCreateReq

        (

        TInt aIpc,

        const CMmDataPackage* aDataPackage,

        TUint8 aTransId

        )

    {

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

OstTraceExt1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_UICCCREATEREQ, "CMmPhoneBookOperationWrite::UICCCreateReq;aIpc=%hd", aIpc );

    TInt ret (KErrNotSupported);

    const CPhoneBookDataPackage* phoneBookData =

        static_cast<const CPhoneBookDataPackage*>( aDataPackage );

            {

                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

                                         iPhoneBookTypeName,

                                         iMmUiccMessHandler->GetCardType() );

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

OstTraceExt1( TRACE_NORMAL, DUP2_CMMPHONEBOOKOPERATIONWRITE_UICCCREATEREQ, "CMmPhoneBookOperationWrite::UICCCreateReq;Unknown aIpc =%hd", aIpc );

            }

    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);

OstTraceExt2( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEL, "CMmPhoneBookOperationWrite::UiccPbReqWriteL;aTransId=%hhu;aIndex=%hd", aTransId, aIndex );

    TInt ret( KErrNone );

        {

        }

        {

        // Check if the index To read is valid

            {

            if( 0 < aIndex )

                {

                        aIndex,

                }

            else

                {

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

                    {

                    //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(

                                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");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEENTRY, "CMmPhoneBookOperationWrite::UiccPBReqWriteEntry" );

    TInt ret( KErrNone );

    TUiccWriteLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*> 

                               ( iMmPhoneBookStoreMessHandler );

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

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

    cmdParams.filePath.Append( APPL_FILE_ID>>8);

    cmdParams.filePath.Append( APPL_FILE_ID);

    if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() )

        {

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

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

        }

    cmdParams.serviceType = UICC_APPL_UPDATE_LINEAR_FIXED;

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

    // Check for valid record number

    if( aIndex <= iMmPhoneBookStoreMessHandler->

        {

        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->

        {

        // Fill rest of the Bytes 

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

            {

            nameBuf.Append( KTagUnusedbyte );

            }

        }

    TBuf8<300>numberBuf;

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

    // 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->

    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);

OstTraceExt1( TRACE_NORMAL, DUP1_CMMPHONEBOOKOPERATIONWRITE_UICCPBREQWRITEENTRY, "CMmPhoneBookOperationWrite::UiccPBReqWriteEntry;ret=%hd", 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");

OstTrace0( TRACE_NORMAL, CMMPHONEBOOKOPERATIONWRITE_UICCPBWRITEEXT, "CMmPhoneBookOperationWrite::UiccPbReqWriteExt" );

    TInt ret( KErrNone );

    TUiccWriteLinearFixed cmdParams;

    cmdParams.messHandlerPtr  = static_cast<MUiccOperationBase*> 

                                ( iMmPhoneBookStoreMessHandler );

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

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

    cmdParams.filePath.Append( APPL_FILE_ID>>8);

    cmdParams.filePath.Append( APPL_FILE_ID);

    if( UICC_CARD_TYPE_UICC == iMmUiccMessHandler->GetCardType() )

        {

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

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

        }