/*

* 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 "HtiSimDirHandlerVPbk.h"

#include "HtiPIMServicePlugin.h"

#include <CVPbkContactManager.h>

#include <CVPbkContactLinkArray.h>

#include <CVPbkContactStoreUriArray.h>

#include <CVPbkContactViewDefinition.h>

#include <CVPbkSortOrder.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactLink.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreInfo.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactView.h>

#include <MVPbkContactViewBase.h>

#include <MVPbkFieldType.h>

#include <MVPbkStoreContact.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkContactStoreObserver.h>

#include <TVPbkContactStoreUriPtr.h>

#include <TVPbkFieldVersitProperty.h>

#include <VPbkContactStoreUris.h>

#include <VPbkContactView.hrh>

#include <VPbkFieldType.hrh>

#include <VPbkEng.rsg>

#include <HtiDispatcherInterface.h>

#include <HTILogging.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KSimInfoResponseLength = 12;

// 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( KErrorSimStoreOpenFailed, "Failed to open SIM contact store" );

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

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// CHtiSimDirHandlerVPbk::NewL

// Two-phased constructor.

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

CHtiSimDirHandlerVPbk* CHtiSimDirHandlerVPbk::NewL()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::NewL" );

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

    CleanupStack::PushL ( self );

    self->ConstructL();

    CleanupStack::Pop();

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::NewL" );

    return self;

    }

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

// CHtiSimDirHandlerVPbk::CHtiSimDirHandlerVPbk

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

// might leave.

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

CHtiSimDirHandlerVPbk::CHtiSimDirHandlerVPbk():iIsBusy( EFalse ),

                                               iIsStoreOpen( EFalse )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::CHtiSimDirHandlerVPbk" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::CHtiSimDirHandlerVPbk" );

    }

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

// CHtiSimDirHandlerVPbk::~CHtiSimDirHandlerVPbk

// Destructor.

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

CHtiSimDirHandlerVPbk::~CHtiSimDirHandlerVPbk()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::~CHtiSimDirHandlerVPbk" );

    if ( iContactView )

        {

        HTI_LOG_TEXT( "Deleting iContactView" );

        iContactView->RemoveObserver( *this );

        delete iContactView;

        }

    if ( iSimStore )

        {

        HTI_LOG_TEXT( "Closing iSimStore" );

        iSimStore->Close( *this );

        }

    if ( iContactManager )

        {

        HTI_LOG_TEXT( "Deleting iContactManager" );

        delete iContactManager;

        }

    if ( iMessage )

        {

        HTI_LOG_TEXT( "Deleting iMessage" );

        delete iMessage;

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::~CHtiSimDirHandlerVPbk" );

    }

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

// CHtiSimDirHandlerVPbk::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CHtiSimDirHandlerVPbk::ConstructL()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ConstructL" );

    CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();

    uriArray->AppendL( TVPbkContactStoreUriPtr(

        VPbkContactStoreUris::SimGlobalAdnUri() ) );

    iContactManager = CVPbkContactManager::NewL( *uriArray );

    CleanupStack::PopAndDestroy( uriArray );

    MVPbkContactStoreList& storeList = iContactManager->ContactStoresL();

    iSimStore = storeList.Find( TVPbkContactStoreUriPtr(

        VPbkContactStoreUris::SimGlobalAdnUri() ) );

    if ( !iSimStore )

        {

        HTI_LOG_TEXT( "SIM ADN store not found - leaving" );

        User::Leave( KErrNotFound );

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ConstructL" );

    }

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

// CHtiSimDirHandlerVPbk::SetDispatcher

// Sets the dispatcher pointer.

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

void CHtiSimDirHandlerVPbk::SetDispatcher( MHtiDispatcher* aDispatcher )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::SetDispatcher" );

    iDispatcher = aDispatcher;

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::SetDispatcher" );

    }

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

// CHtiSimDirHandlerVPbk::ProcessMessageL

// Parses the received message and calls handler functions.

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

void CHtiSimDirHandlerVPbk::ProcessMessageL( const TDesC8& aMessage,

    THtiMessagePriority /*aPriority*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ProcessMessageL" );

    if ( iIsBusy )

        {

        HTI_LOG_TEXT( "HtiSimDirHandlerVPbk is busy - leaving" );

        User::Leave( KErrInUse );

        }

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

    iIsBusy = ETrue;

    delete iMessage;

    iMessage = NULL;

    // Zero legth of aMessage tested already in CHtiPIMServicePlugin.

    // Other sanity checks must be done here.

    // Trap the AllocL to be able to set iIsBusy false before leaving.

    TRAPD( err, iMessage = aMessage.Right( aMessage.Length() - 1 ).AllocL() );

    if ( err != KErrNone )

        {

        iIsBusy = EFalse;

        User::Leave( err );

        }

    iCommand = aMessage.Ptr()[0];

    // Do basic validity checking for message

    TBool isParamsOk = ETrue;

    switch ( iCommand )

        {

        case CHtiPIMServicePlugin::ESimCardInfo:

            {

            if ( iMessage->Length() != 0 )

                {

                isParamsOk = EFalse;

                }

            break;

            }

        case CHtiPIMServicePlugin::EImportSimContact:

            {

            if ( !CheckImportMsg() )

                {

                isParamsOk = EFalse;

                }

            break;

            }

        case CHtiPIMServicePlugin::EDeleteSimContact:

            {

            if ( iMessage->Length() != 4 && iMessage->Length() != 0 )

                {

                isParamsOk = EFalse;

                }

            break;

            }

        default:

            {

            SendErrorMessageL( KErrArgument, KErrorUnrecognizedCommand );

            return;

            }

        }

    if ( !isParamsOk )

        {

        SendErrorMessageL( KErrArgument, KErrorInvalidParameters );

        }

    else

        {

        if ( iIsStoreOpen )

            {

            StoreReady( *iSimStore );

            }

        else

            {

            // Start async open operation.

            // StoreReady callback will be called when opening is complete.

            TRAPD( err, iSimStore->OpenL( *this ) );

            if ( err != KErrNone )

                {

                HTI_LOG_FORMAT(

                        "Leave from CHtiSimDirHandler::OpenL() %d", err );

                SendErrorMessageL( err, KErrorSimStoreOpenFailed );

                }

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ProcessMessageL" );

    }

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

// CHtiSimDirHandlerVPbk::IsBusy

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

//

TBool CHtiSimDirHandlerVPbk::IsBusy()

    {

    return iIsBusy;

    }

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

// CHtiSimDirHandlerVPbk::OpenComplete

// Called when the opening process is complete.

// From MVPbkContactStoreListObserver

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

/*

void CHtiSimDirHandlerVPbk::OpenComplete()

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::OpenComplete" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::OpenComplete" );

    }

*/

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

// CHtiSimDirHandlerVPbk::StoreReady

// Called when a contact store is ready to use.

// From MVPbkContactStoreObserver

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

void CHtiSimDirHandlerVPbk::StoreReady( MVPbkContactStore& aContactStore )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::StoreReady" );

    if ( !iIsBusy || iSimStore != &aContactStore )

        {

        return;

        }

    iIsStoreOpen = ETrue;

    if ( iCommand == CHtiPIMServicePlugin::ESimCardInfo )

        {

        TRAPD( err, HandleSimCardInfoL() );

        if ( err != KErrNone )

            {

            TRAP_IGNORE( SendErrorMessageL( err, KErrorSimCardInfoFailed ) );

            }

        }

    else if ( iCommand == CHtiPIMServicePlugin::EImportSimContact )

        {

        TRAPD( err, HandleSimContactImportL() );

        if ( err != KErrNone )

            {

            TRAP_IGNORE( SendErrorMessageL( err, KErrorImportFailed ) );

            }

        }

    else if ( iCommand == CHtiPIMServicePlugin::EDeleteSimContact )

        {

        TRAPD( err, HandleSimContactDeleteL() );

        if ( err != KErrNone )

            {

            TRAP_IGNORE( SendErrorMessageL( err, KErrorDeleteFailed ) );

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::StoreReady" );

    }

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

// CHtiSimDirHandlerVPbk::StoreUnavailable

// Called when a contact store becomes unavailable.

// From MVPbkContactStoreObserver

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

void CHtiSimDirHandlerVPbk::StoreUnavailable( MVPbkContactStore& aContactStore,

                                              TInt aReason )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::StoreUnavailable" );

    if ( iIsBusy && iSimStore == &aContactStore )

        {

        TRAP_IGNORE( SendErrorMessageL( aReason, KErrorSimStoreUnavailable ) );

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::StoreUnavailable" );

    }

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

// CHtiSimDirHandlerVPbk::HandleStoreEventL

// Called when changes occur in the contact store.

// From MVPbkContactStoreObserver

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

void CHtiSimDirHandlerVPbk::HandleStoreEventL( MVPbkContactStore& aContactStore,

                        TVPbkContactStoreEvent aStoreEvent )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::HandleStoreEventL" );

    if ( iIsBusy && iSimStore == &aContactStore &&

         aStoreEvent.iEventType == TVPbkContactStoreEvent::EContactAdded )

        {

        HTI_LOG_TEXT( "Contact added" );

        TInt entryId = 0;

        TBuf8<4> idBuf;

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

        TRAP_IGNORE( SendOkMsgL( idBuf ) );

        }

    else if ( iIsBusy && iSimStore == &aContactStore &&

              aStoreEvent.iEventType == TVPbkContactStoreEvent::EContactDeleted )

        {

        HTI_LOG_TEXT( "Contact deleted" );

        if ( iMessage->Length() > 0 )  // This is a single deletion

            {

            TRAP_IGNORE( SendOkMsgL( KNullDesC8 ) );

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::HandleStoreEventL" );

    }

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

// CHtiSimDirHandlerVPbk::ContactOperationCompleted

// Called when a contact operation has succesfully completed.

// From MVPbkContactObserver

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

void CHtiSimDirHandlerVPbk::ContactOperationCompleted( TContactOpResult /*aResult*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactOperationCompleted" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactOperationCompleted" );

    }

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

// CHtiSimDirHandlerVPbk::ContactOperationFailed

// Called when a contact operation has failed.

// From MVPbkContactObserver

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

void CHtiSimDirHandlerVPbk::ContactOperationFailed( TContactOp /*aOpCode*/,

                                                    TInt /*aErrorCode*/,

                                                    TBool /*aErrorNotified*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactOperationFailed" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactOperationFailed" );

    }

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

// CHtiSimDirHandlerVPbk::ContactViewReady

// Called when a view is ready for use.

// From MVPbkContactViewObserver

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

void CHtiSimDirHandlerVPbk::ContactViewReady( MVPbkContactViewBase& aView )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactViewReady" );

    if ( iContactView == &aView && iIsBusy &&

            iCommand == CHtiPIMServicePlugin::EDeleteSimContact )

        {

        TRAPD( err, DeleteContactsInViewL() );

        if ( err != KErrNone )

            {

            TRAP_IGNORE( SendErrorMessageL( err, KErrorDeleteFailed ) );

            }

        }

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactViewReady" );

    }

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

// CHtiSimDirHandlerVPbk::ContactViewUnavailable

// Called when a view is unavailable for a while.

// From MVPbkContactViewObserver

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

void CHtiSimDirHandlerVPbk::ContactViewUnavailable( MVPbkContactViewBase& /*aView*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactViewUnavailable" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactViewUnavailable" );

    }

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

// CHtiSimDirHandlerVPbk::ContactAddedToView

// Called when a contact has been added to the view.

// From MVPbkContactViewObserver

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

void CHtiSimDirHandlerVPbk::ContactAddedToView( MVPbkContactViewBase& /*aView*/,

        TInt /*aIndex*/, const MVPbkContactLink& /*aContactLink*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactAddedToView" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactAddedToView" );

    }

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

// CHtiSimDirHandlerVPbk::ContactRemovedFromView

// Called when a contact has been removed from a view.

// From MVPbkContactViewObserver

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

void CHtiSimDirHandlerVPbk::ContactRemovedFromView( MVPbkContactViewBase& /*aView*/,

        TInt /*aIndex*/, const MVPbkContactLink& /*aContactLink*/ )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactRemovedFromView" );

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactRemovedFromView" );

    }

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

// CHtiSimDirHandlerVPbk::ContactViewError

// Called when an error occurs in the view.

// From MVPbkContactViewObserver

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

void CHtiSimDirHandlerVPbk::ContactViewError( MVPbkContactViewBase& aView,

                                              TInt aError,

                                              TBool aErrorNotified )

    {

    HTI_LOG_FUNC_IN( "CHtiSimDirHandlerVPbk::ContactViewError" );

    HTI_LOG_FORMAT( "CHtiSimDirHandlerVPbk::ContactViewError: %d", aError );

    HTI_LOG_FORMAT( "ErrorNotified = %d", aErrorNotified );

    if ( iContactView == &aView )

        {

        iContactView->RemoveObserver( *this );

        if ( iIsBusy && iCommand == CHtiPIMServicePlugin::EDeleteSimContact )

            {

            SendErrorMessageL( aError, KErrorDeleteFailed );

            }

        }

    aErrorNotified = aErrorNotified;  // avoid compiler warning

    HTI_LOG_FUNC_OUT( "CHtiSimDirHandlerVPbk::ContactViewError" );

    }

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

// CHtiSimDirHandlerVPbk::StepComplete

// Called when one step of the batch operation is complete.

// From MVPbkBatchOperationObserver

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

void CHtiSimDirHandlerVPbk::StepComplete( MVPbkContactOperationBase& /*aOperation*/,