/*

 * Copyright (c) 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:  Implementation of SIM card contacts handling using the new

 *                Virtual Phonebook API

 *

 */

// INCLUDE FILES

#include "HtiSimDirHandler.h"

#include "HtiPIMServicePlugin.h"

#include <HtiDispatcherInterface.h>

#include <HtiLogging.h>

#include <mmtsy_names.h>

#include <mpbutil.h> 

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KSimInfoResponseLength = 12;

const TInt KOneSimContactBufferSize = 512;

// MACROS

// LOCAL CONSTANTS AND MACROS

_LIT8( KErrorUnrecognizedCommand, "Unrecognized command" );

_LIT8( KErrorInvalidParameters, "Invalid command parameters" );

_LIT8( KErrorImportFailed, "Contact import failed" );

_LIT8( KErrorDeleteFailed, "Failed to delete contact" );

_LIT8( KErrorSimCardInfoFailed, "Failed to get SIM card info" );

_LIT8( KErrorFieldNotSupported, "Field is not supported");

_LIT8( KErrorFieldTooBig, "Filed is too long");

//_LIT8( KErrorSimStoreOpenFailed, "Failed to open SIM contact store" );

//_LIT8( KErrorSimStoreUnavailable, "SIM contact store unavailable" );

//_LIT8( KErrorContactOperationFailed, "SIM contact operation failed" );

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiSimDirHandler::NewL

// Two-phased constructor.

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

CHtiSimDirHandler* CHtiSimDirHandler::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::NewL" );

    CHtiSimDirHandler* self = new (ELeave) CHtiSimDirHandler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::NewL" );

    return self;

    }

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

// CHtiSimDirHandler::CHtiSimDirHandler

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

// might leave.

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

CHtiSimDirHandler::CHtiSimDirHandler() :

    iIsBusy(EFalse), iStoreIsOpen(EFalse)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::CHtiSimDirHandler" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::CHtiSimDirHandler" );

    }

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

// CHtiSimDirHandler::~CHtiSimDirHandler

// Destructor.

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

CHtiSimDirHandler::~CHtiSimDirHandler()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::~CHtiSimDirHandler" );

    iEtelStore.Close();

    iEtelPhone.Close();

    iEtelServer.Close();

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::~CHtiSimDirHandler" );

    }

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

// CHtiSimDirHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiSimDirHandler::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::ConstructL" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::ConstructL" );

    }

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

// CHtiSimDirHandler::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiSimDirHandler::SetDispatcher(MHtiDispatcher* aDispatcher)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::SetDispatcher" );

    }

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

// CHtiSimDirHandler::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiSimDirHandler::ProcessMessageL(const TDesC8& aMessage,

        THtiMessagePriority /*aPriority*/)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::ProcessMessageL" );

    if (iStoreIsOpen == EFalse)

        {

        User::LeaveIfError(iEtelServer.Connect());

        User::LeaveIfError(iEtelServer.LoadPhoneModule(KMmTsyModuleName));

        User::LeaveIfError(iEtelPhone.Open(iEtelServer, KMmTsyPhoneName));

        User::LeaveIfError(iEtelStore.Open(iEtelPhone, KETelIccAdnPhoneBook));

        HTI_LOG_TEXT( "SIM card open" );

        iStoreIsOpen = ETrue;

        }

    if (iIsBusy)

        {

        HTI_LOG_TEXT( "HtiSimDirHandler is busy - leaving" );

        User::Leave(KErrInUse);

        }

    // Will be set to EFalse in the SendOkMsgL or SendErrorMessageL methods.

    iIsBusy = ETrue;

    // Zero legth of aMessage tested already in CHtiPIMServicePlugin.

    // Other sanity checks must be done here.

    TInt err = KErrNone;

    TUint8 command = aMessage.Ptr()[0];

    switch (command)

        {

        case CHtiPIMServicePlugin::ESimCardInfo:

            {

            TRAP(err ,HandleSimCardInfoL(aMessage.Right(aMessage.Length() - 1)));

            break;

            }

        case CHtiPIMServicePlugin::EImportSimContact:

            {

            TRAP(err ,HandleSimContactImportL(aMessage.Right(aMessage.Length() - 1)));

            break;

            }

        case CHtiPIMServicePlugin::EDeleteSimContact:

            {

            TRAP(err ,HandleSimContactDeleteL(aMessage.Right(aMessage.Length() - 1)));

            break;

            }

        default:

            {

            SendErrorMessageL(KErrArgument, KErrorUnrecognizedCommand);

            return;

            }

        }

    if (err != KErrNone)

        {

        iIsBusy = EFalse;

        User::Leave(err);

        } 

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::ProcessMessageL" );

    }

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

// CHtiSimDirHandler::IsBusy

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

//

TBool CHtiSimDirHandler::IsBusy()

    {

    return iIsBusy;

    }

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

// CHtiSimDirHandler::HandleSimCardInfoL

// Gets information about the SIM card.

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

void CHtiSimDirHandler::HandleSimCardInfoL(const TDesC8& aData)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::HandleSimCardInfoL" );

    if (aData.Length() != 0)

        {

        HTI_LOG_TEXT( "CHtiSimDirHandler: wrong length of data" );

        SendErrorMessageL(KErrArgument, KErrorInvalidParameters);

        return;

        }

    RMobilePhoneBookStore::TMobilePhoneBookInfoV5 etelStoreInfo;

    RMobilePhoneBookStore::TMobilePhoneBookInfoV5Pckg etelStoreInfoPckg(etelStoreInfo);

    TRequestStatus requestStatus;

    iEtelStore.GetInfo(requestStatus, (TDes8&) etelStoreInfoPckg);

    User::WaitForRequest(requestStatus);

    if (requestStatus.Int() != KErrNone)

        {

        HTI_LOG_TEXT( "CHtiSimDirHandler: Failed to get SIM card info" );

        SendErrorMessageL(requestStatus.Int(), KErrorSimCardInfoFailed);

        return;

        }

    // Create and send response message

    TBuf8<KSimInfoResponseLength> reply;

    reply.Append(etelStoreInfo.iMaxSecondNames > 0 ? etelStoreInfo.iMaxSecondNames : 0);

    reply.Append(etelStoreInfo.iMaxAdditionalNumbers > 0 ? etelStoreInfo.iMaxAdditionalNumbers : 0);

    reply.Append(etelStoreInfo.iMaxEmailAddr > 0 ? etelStoreInfo.iMaxEmailAddr : 0);

    reply.Append(etelStoreInfo.iMaxTextLength > 0 ? etelStoreInfo.iMaxTextLength : 0);

    reply.Append(etelStoreInfo.iMaxNumLength > 0 ? etelStoreInfo.iMaxNumLength : 0);

    reply.Append(etelStoreInfo.iMaxTextLengthSecondName > 0 ? 

        etelStoreInfo.iMaxTextLengthSecondName : 0);

    reply.Append(etelStoreInfo.iMaxNumLengthAdditionalNumber > 0?

        etelStoreInfo.iMaxNumLengthAdditionalNumber : 0);

    reply.Append(etelStoreInfo.iMaxTextLengthEmailAddr > 0 ? etelStoreInfo.iMaxTextLengthEmailAddr : 0);

    reply.Append( ( TUint8* ) ( &etelStoreInfo.iTotalEntries ), 2 );

    reply.Append( ( TUint8* ) ( &etelStoreInfo.iUsedEntries ), 2 );

    SendOkMsgL(reply);

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::HandleSimCardInfoL" );

    }

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

// CHtiSimDirHandler::HandleSimContactImportL

// Imports the contact to SIM card.

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

void CHtiSimDirHandler::HandleSimContactImportL(const TDesC8& aData)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::HandleSimContactImportL" );

    if(CheckImportMsg(aData) == EFalse)

        {

        return;

        }

    RBuf8 buffer;

    buffer.CreateL(KOneSimContactBufferSize);

    CleanupClosePushL(buffer);

    CPhoneBookBuffer* pbBuffer = new (ELeave) CPhoneBookBuffer();

    CleanupStack::PushL(pbBuffer);

    pbBuffer->Set(&buffer);

    //add new enty tag

    User::LeaveIfError(pbBuffer->AddNewEntryTag());

    TInt offset = 0;

    TInt fieldCount = aData[offset];

    offset++;

    for (TInt i = 0; i < fieldCount; i++)

        {

        HTI_LOG_FORMAT( "Processing field %d", i + 1 );

        TContactFieldType type = (TContactFieldType) aData[offset];

        offset++;

        TInt fieldLength = aData[offset];

        offset++;

        HBufC* fieldData = HBufC::NewLC(fieldLength);

        fieldData->Des().Copy(aData.Mid(offset, fieldLength));

        switch (type)

            {

            case ENameField:

                User::LeaveIfError(pbBuffer->PutTagAndValue(

                        RMobilePhoneBookStore::ETagPBText, fieldData->Des()));

                break;

            case ESecondNameField:

                User::LeaveIfError(pbBuffer->PutTagAndValue(

                        RMobilePhoneBookStore::ETagPBSecondName,

                        fieldData->Des()));

                break;

            case EPhoneNumberField:

                User::LeaveIfError(

                        pbBuffer->PutTagAndValue(

                                RMobilePhoneBookStore::ETagPBNumber,

                                fieldData->Des()));

                break;

            case EEMailField:

                User::LeaveIfError(pbBuffer->PutTagAndValue(

                        RMobilePhoneBookStore::ETagPBEmailAddress,

                        fieldData->Des()));

                break;

            case EAdditNumberField:

                User::LeaveIfError(pbBuffer->AddNewNumberTag());

                User::LeaveIfError(

                        pbBuffer->PutTagAndValue(

                                RMobilePhoneBookStore::ETagPBNumber,

                                fieldData->Des()));

                break;

            default:

                HTI_LOG_FORMAT( "Unknown field type %d", type );

                User::Leave(KErrArgument);

                break;

            }

        CleanupStack::PopAndDestroy(); // fieldData

        offset += fieldLength;

        }

    // save contact into sim card

    TInt index = -1;

    TRequestStatus status;

    //store the entry in the first free location and then return 

    //this location within index when it completes the request

    iEtelStore.Write(status, buffer, index);

    User::WaitForRequest(status);

    if(status.Int() != KErrNone)

        {

        HTI_LOG_TEXT("Failed to add SIM contact");

        SendErrorMessageL( status.Int(), KErrorImportFailed );

        }

    else

        {

        HTI_LOG_TEXT( "SIM contact added" );

        TBuf8<4> idBuf;

        idBuf.Append( ( TUint8* ) &index, 4 );

        SendOkMsgL( idBuf );

        }

    CleanupStack::PopAndDestroy(2); // buffer, pbBuffer

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::HandleSimContactImportL" );

    }

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

// CHtiSimDirHandler::HandleSimContactDeleteL

// Creates a contact view containing the contacts to be deleted.

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

void CHtiSimDirHandler::HandleSimContactDeleteL(const TDesC8& aData)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::HandleSimContactDeleteL" );

    TInt dataLength = aData.Length();

    if ( dataLength != 0 && dataLength != 4 )

        {

        HTI_LOG_TEXT( "CHtiSimDirHandler: Wrong length of data" )

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return;

        }

    TRequestStatus status;

    if (dataLength == 0) //delete all

        {

        iEtelStore.DeleteAll(status);

        HTI_LOG_TEXT("Delete all SIM contacts");

        }

    else //delete one contact with given id

        {

        TInt id = aData[0] + (aData[1] << 8) + (aData[2] << 16) + (aData[3]

                << 24);

        HTI_LOG_FORMAT( "Delete SIM contact with id %d", id );

        iEtelStore.Delete(status, id);

        }

    User::WaitForRequest(status);

    if(status.Int() != KErrNone)

        {

        HTI_LOG_TEXT("Failed to delete contact(s)");

        SendErrorMessageL( status.Int(), KErrorDeleteFailed );

        }

    else

        {

        HTI_LOG_TEXT("SIM contact(s) deleted");

        SendOkMsgL( KNullDesC8 );

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::HandleSimContactDeleteL" );

    }

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

// CHtiSimDirHandler::CheckImportMsg

// Validates the syntax of import contact message.

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

TBool CHtiSimDirHandler::CheckImportMsg(const TDesC8& aData)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::CheckImportMsg" );

    // Import command syntax:

    //   amount of fields     (1 byte)   __

    //   type of field        (1 byte)     |

    //   length of data field (1 byte)     | repeated <amount of fields> times

    //   field data           (variable) __|

    TInt length = aData.Length();

    if (length < 4) // min length 4 bytes

        {

        HTI_LOG_FORMAT( "Message too short %d", length );

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return EFalse;

        }

    RMobilePhoneBookStore::TMobilePhoneBookInfoV5 etelStoreInfo;

    RMobilePhoneBookStore::TMobilePhoneBookInfoV5Pckg etelStoreInfoPckg(etelStoreInfo);

    TRequestStatus requestStatus;

    iEtelStore.GetInfo(requestStatus, (TDes8&) etelStoreInfoPckg);

    User::WaitForRequest(requestStatus);

    if (requestStatus.Int() != KErrNone)

        {

        HTI_LOG_TEXT( "CHtiSimDirHandler: Failed to get SIM card info" );

        SendErrorMessageL(requestStatus.Int(), KErrorSimCardInfoFailed);

        return EFalse;

        }

    TInt offset = 0;

    TInt fieldCount = aData[offset];

    HTI_LOG_FORMAT( "Fields %d", fieldCount );

    if (fieldCount < 1) // must be at least one field

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        return EFalse;

        }

    offset++;

    TInt fieldsFound = 0;

    while (offset < length)

        {

        fieldsFound++;

        TContactFieldType fieldType = (TContactFieldType) aData[offset];

        HTI_LOG_FORMAT( "Field type %d", fieldType );

        TInt maxLength = 0;

        if(fieldType == ENameField)

            {

            maxLength = etelStoreInfo.iMaxTextLength;

            }

        else if(fieldType == ESecondNameField)

            {

            maxLength = etelStoreInfo.iMaxTextLengthSecondName;

            }

        else if(fieldType == EPhoneNumberField)

            {

            maxLength = etelStoreInfo.iMaxNumLength;

            }

        else if(fieldType == EEMailField)

            {

            maxLength = etelStoreInfo.iMaxTextLengthEmailAddr;

            }

        else if(fieldType == EAdditNumberField)

            {

            maxLength = etelStoreInfo.iMaxNumLengthAdditionalNumber;

            }

        else

            {

            HTI_LOG_TEXT("Unknown field type");

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            return EFalse; // invalid field type

            }

        if(maxLength <= 0)

            {

            HTI_LOG_TEXT("Field not supported");

            SendErrorMessageL(KErrArgument, KErrorFieldNotSupported);

            return EFalse;

            }

        offset++; // the type of field byte

        if (offset >= length)

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            return EFalse;

            }

        TInt fieldLength = aData[offset];

        HTI_LOG_FORMAT( "Field length %d", fieldLength );

        if (fieldLength < 1)

            {

            SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

            return EFalse; // Field data can not be empty

            }

        else if(fieldLength > maxLength)

            {

            HTI_LOG_TEXT("The length of field is too long");

            SendErrorMessageL( KErrArgument, KErrorFieldTooBig );

            return EFalse;

            }

        offset++; // advance over the length of data byte

        offset += fieldLength; // and the field data

        }

    if (offset == length && fieldsFound == fieldCount)

        {

        HTI_LOG_TEXT( "Message OK" );

        return ETrue;

        }

    SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

    return EFalse;

    }

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

// CHtiSimDirHandler::SendOkMsgL

// Helper function for sending response messages.

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

void CHtiSimDirHandler::SendOkMsgL(const TDesC8& aData)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::SendOkMsgL" );

    iIsBusy = EFalse; // Done with the current request

    User::LeaveIfNull(iDispatcher);

    HBufC8* temp = HBufC8::NewL(aData.Length() + 1);

    TPtr8 response = temp->Des();

    response.Append((TChar) CHtiPIMServicePlugin::EResultOk);

    response.Append(aData);

    User::LeaveIfError(iDispatcher->DispatchOutgoingMessage(temp,

            KPIMServiceUid));

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::SendOkMsgL" );

    }

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

// CHtiSimDirHandler::SendErrorMessageL

// Helper function for sending error response messages.

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

void CHtiSimDirHandler::SendErrorMessageL(TInt aError,

        const TDesC8& aDescription)

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandler::SendErrorMessageL" );

    iIsBusy = EFalse; // Done with the current request

    User::LeaveIfNull(iDispatcher);

    User::LeaveIfError(iDispatcher->DispatchOutgoingErrorMessage(aError,

            aDescription, KPIMServiceUid));

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandler::SendErrorMessageL" );

    }