/*

* Copyright (c) 2007-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:  ESMR Contact Handler for fetching contacts for attendee field

*

*/

#include "emailtrace.h"

#include "cesmrcontacthandler.h"

//INCLUDES

#include <eikenv.h>

#include <StringLoader.h>

#include <s32mem.h>

//Virtual Phonebook

#include <CVPbkContactManager.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkStoreContact.h>

#include <MVPbkFieldType.h>

#include <VPbkEng.rsg>

#include <CVPbkContactFieldIterator.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactLink.h>

//Remote Contact Lookup

//<cmail>

#include "cpbkxremotecontactlookupenv.h"

#include <cntitem.h>

#include <CPbk2SortOrderManager.h>

// Aiw launcher

#include <AiwCommon.hrh>

#include <AiwContactSelectionDataTypes.h>

#include <AiwServiceHandler.h>

#include <AiwGenericParam.h>

//FS Email framework

//</cmail>

//MRUI

#include <esmrgui.rsg>

#include "cesmrcontactmanagerhandler.h"

#include "cesmrclslistshandler.h"

#include "mesmrcontacthandlerobserver.h"

#include "cesmrclsitem.h"

#include "esmrfieldbuilderdef.h"

// Constants

// Unnamed namespace for local definitions

namespace{

template<typename T> class CleanupResetAndDestroyClose

    {

    public:

        inline static void PushL( T& aRef );

    private:

        static void Close( TAny *aPtr );

    };

template<typename T> inline void CleanupResetAndDestroyClose<T>::PushL( T& aRef )

    {

    CleanupStack::PushL( TCleanupItem( &Close, &aRef ) );

    }

template<typename T> void CleanupResetAndDestroyClose<T>::Close( TAny *aPtr )

    {

    static_cast<T*>(aPtr)->ResetAndDestroy();

    static_cast<T*>(aPtr)->Close();

    }

template<typename T> inline void CleanupResetAndDestroyClosePushL( T& aRef )

    {

    CleanupResetAndDestroyClose<T>::PushL( aRef );

    }

}//namespace

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

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

// CESMRContactHandler::NewL

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

//

CESMRContactHandler* CESMRContactHandler::NewL()

    {

    FUNC_LOG;

    CESMRContactHandler* self = CESMRContactHandler::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CESMRContactHandler::NewLC

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

//

CESMRContactHandler* CESMRContactHandler::NewLC()

    {

    FUNC_LOG;

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CESMRContactHandler::CESMRContactHandler

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

//

CESMRContactHandler::CESMRContactHandler():

    iState(EContactHandlerIdle)

    {

    FUNC_LOG;

    //do nothing

    }

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

// CESMRContactHandler::ConstructL

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

//

void CESMRContactHandler::ConstructL()

    {

    FUNC_LOG;

    iESMRStatic.ConnectL();

    CESMRContactManagerHandler& contactManagerHandler = iESMRStatic.ContactManagerHandlerL();

    if ( !contactManagerHandler.IsReady() )

        {

        contactManagerHandler.AddObserverL( this );

        }

    iContactManager = &contactManagerHandler.GetContactManager();

    }

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

// CESMRContactHandler::ContactManagerReady

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

//

void CESMRContactHandler::ContactManagerReady()

    {

    FUNC_LOG;

    CESMRContactManagerHandler* contactManagerHandler = NULL;

    TRAPD( error, contactManagerHandler = &iESMRStatic.ContactManagerHandlerL());

    if ( error != KErrNone )

        {

        CEikonEnv::Static()->HandleError(error);// codescanner::eikonenvstatic

        }

    else

        {

        contactManagerHandler->RemoveObserver( this );

        }

    }

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

// CESMRContactHandler::~CESMRContactHandler

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

//

CESMRContactHandler::~CESMRContactHandler()

    {

    FUNC_LOG;

    delete iClsListHandler;

    delete iServiceHandler;

    iLastnameFields.Reset();

    iFirstnameFields.Reset();

    iEmailFields.Reset();

    delete iSearchMatch;

    iContactObjects.ResetAndDestroy();

    delete iLinksSet;

    delete iLinkOperationFetch;

    delete iCurrentLink;

    iESMRStatic.Close();

    if(iESMRMailBoxStaticCalled)

        {

        iESMRMailBoxStatic.Close();

        }

    }

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

// CESMRContactHandler::SearchMatchesL

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

//

void CESMRContactHandler::SearchMatchesL( const TDesC& aText,

                                          MESMRContactHandlerObserver* aObserver )

    {

    FUNC_LOG;

    if ( (iState == EContactHandlerIdle) ||

         (iState == EContactHandlerSearchMatches)  )

        {

        iState = EContactHandlerSearchMatches;

        iHandlerObserver = aObserver;

        //delayed launch of listhandler

        if(!iClsListHandler)

            {

            iClsListHandler = CESMRClsListsHandler::NewL(

                    CEikonEnv::Static()->FsSession(), // codescanner::eikonenvstatic

                    iContactManager );

            iClsListHandler->SetObserver( this );

            }

        iClsListHandler->SetCurrentMailboxL( &DelayedMailBoxL() );

        iClsListHandler->SearchMatchesL( aText );

        }

    }

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

// CESMRContactHandler::RemoteLookupSupportedL

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

//

TBool CESMRContactHandler::RemoteLookupSupportedL()

    {

    FUNC_LOG;

    DelayedMailBoxL();

    return iRemoteLookupSupported;

    }

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

// CESMRContactHandler::DelayedMailBoxL

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

//

CFSMailBox& CESMRContactHandler::DelayedMailBoxL()

    {

    FUNC_LOG;

    if(!iESMRMailBoxStaticCalled)

        {

        iESMRMailBoxStatic.ConnectL();

        iMailBox = &iESMRMailBoxStatic.DefaultFSMailBoxL();

        iRemoteLookupSupported = iMailBox->HasCapability( EFSMBoxCapaSupportsRCL );

        iESMRMailBoxStaticCalled = ETrue;

        }

    return *iMailBox;

    }

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

// CESMRContactHandler::GetContactManager

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

//

CVPbkContactManager* CESMRContactHandler::GetContactManager()

    {

    FUNC_LOG;

    return iContactManager;

    }

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

// CESMRContactHandler::GetAddressesFromPhonebookL

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

//

void CESMRContactHandler::GetAddressesFromPhonebookL( MESMRContactHandlerObserver* aObserver )

    {

    FUNC_LOG;

    if ( iState == EContactHandlerIdle )

        {

        if ( !aObserver )

            {

            //Request can't be fulfilled without observer

            return;

            }

        iHandlerObserver = aObserver;

        iState = EContactHandlerGetAddressesFromPhonebook;

        TUint fetchFlags = 0;

        iContactObjects.ResetAndDestroy();

        //start service handler and add the interests of this class

        if(!iServiceHandler)

            {

            iServiceHandler = CAiwServiceHandler::NewL();

            iServiceHandler->AttachL( R_CONTACT_SELECTION_INTEREST );

            }

        CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();

        inParamList.AppendL(

                TAiwGenericParam(

                        EGenericParamContactSelectionData,

                        TAiwVariant(TAiwMultipleItemSelectionDataV1Pckg(

                                TAiwMultipleItemSelectionDataV1().

                                SetAddressSelectType(EAiwEMailSelect).

                                SetFlags( fetchFlags )))));

        iServiceHandler->ExecuteServiceCmdL(

                KAiwCmdSelect,

                inParamList,

                iServiceHandler->OutParamListL(),

                0,

                this);

        }

    }

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

// CESMRContactHandler::ArrayUpdatedL

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

//

void CESMRContactHandler::ArrayUpdatedL( RPointerArray<CESMRClsItem>& aMatchingItems )

    {

    FUNC_LOG;

    switch ( iState )

            {

            case EContactHandlerSearchMatches:

                if ( aMatchingItems.Count() == 1 )

                    {

                    if ( !iSearchMatch )

                        {

                        iSearchMatch = CESMRClsItem::NewL();

                        }

                    iSearchMatch->SetDisplayNameL( aMatchingItems[0]->DisplayName() );

                    iSearchMatch->SetEmailAddressL( aMatchingItems[0]->EmailAddress() );

                    }

                else

                    {

                    delete iSearchMatch;

                    iSearchMatch = NULL;

                    }

                // The ownership of the array content is transferred to observer.

                iState = EContactHandlerIdle;

                if ( iHandlerObserver )

                    {

                    iHandlerObserver->OperationCompleteL( ESearchContacts, &aMatchingItems );

                    }

                break;

            default:

                break;

            }

    }

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

// CESMRContactHandler::OperationErrorL

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

//

void CESMRContactHandler::OperationErrorL( TInt aErrorCode )

    {

    FUNC_LOG;

    if ( aErrorCode != KErrNone )

        {

        iState = EContactHandlerIdle;

        if ( iHandlerObserver )

            {

            iHandlerObserver->OperationErrorL( ESearchContacts, aErrorCode );

            }

        }

    }

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

// CESMRContactHandler::VPbkSingleContactOperationComplete

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

//

void CESMRContactHandler::VPbkSingleContactOperationComplete(

        MVPbkContactOperationBase& aOperation,

        MVPbkStoreContact* aContact )

    {

    FUNC_LOG;

    TRAP_IGNORE( VPbkSingleContactOperationCompleteL( aOperation, aContact) );

    }

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

// CESMRContactHandler::VPbkSingleContactOperationFailed

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

//

void CESMRContactHandler::VPbkSingleContactOperationFailed(

        MVPbkContactOperationBase& aOperation, TInt aError )

    {

    FUNC_LOG;

    TRAP_IGNORE( VPbkSingleContactOperationFailedL( aOperation, aError ) );

    }

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

// CESMRContactHandler::VPbkSingleContactOperationFailedL

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

//

void CESMRContactHandler::VPbkSingleContactOperationFailedL(

        MVPbkContactOperationBase& /*aOperation*/, TInt aError )

    {

    FUNC_LOG;

    iState = EContactHandlerIdle;

    if ( iHandlerObserver )

        {

        iHandlerObserver->OperationErrorL( EGetAddressesFromPhonebook, aError );

        iHandlerObserver = NULL;

        }

    }

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

// CESMRContactHandler::HandleNotifyL

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

//

TInt CESMRContactHandler::HandleNotifyL( TInt aCmdId, 

                                         TInt aEventId,

                                         CAiwGenericParamList& aEventParamList,

                                         const CAiwGenericParamList& /*aInParamList*/)

    {

    FUNC_LOG;

    TInt result = 0;

    if ( (aCmdId == KAiwCmdSelect) && 

         (iState == EContactHandlerGetAddressesFromPhonebook) &&

         (aEventId == KAiwEventCompleted))

        {

        TInt index = 0;

        const TAiwGenericParam* param = 

            aEventParamList.FindFirst(index, EGenericParamContactLinkArray);

        if (param)

            {

            TPtrC8 contactLinks = param->Value().AsData();

            iLinksSet = iContactManager->CreateLinksLC(contactLinks);

            CleanupStack::Pop();

            if ( iLinksSet->Count() )

                {

                iCurrentLink = &iLinksSet->At(0);

                iLinkOperationFetch = iContactManager->RetrieveContactL( 

                        iLinksSet->At(0), *this );

                }

            }

        }

    else if ( aEventId == KAiwEventError )

        {

        iState = EContactHandlerIdle;

        if ( iHandlerObserver )

            {

            //Notify caller of the error

            iHandlerObserver->OperationErrorL( ESearchContacts, KErrGeneral );

            iHandlerObserver = NULL;

            }

        }

    else if ( (aEventId == KAiwEventQueryExit) )

        {

        // We don't need to check outParams, 

        // or do anything special during the exit

        result = 1;

        }

    else if ( aEventId == KAiwEventOutParamCheck && aCmdId == KAiwCmdSelect )

        {

        // We want select this contact

        result = 1;

        }

    else if ( aEventId == KAiwEventCanceled )

        {

        iState = EContactHandlerIdle;

        if ( iHandlerObserver )

            {

            RPointerArray<CESMRClsItem> emptyItems;

            iHandlerObserver->OperationCompleteL( ESearchContacts, &emptyItems );

            emptyItems.Close();

            iHandlerObserver = NULL;

            }

        }

    return result;

    }

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

// CESMRContactHandler::GetContactFieldsL

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

//

void CESMRContactHandler::GetContactFieldsL( RArray<TInt>& aFieldIds, RPointerArray<HBufC>& aNumbers,

                                                 MVPbkStoreContact* aContact)

    {

    FUNC_LOG;

    for (TInt i = 0; i < aFieldIds.Count(); i++ )

        {

        const MVPbkFieldType*  myContactDataField =

        iContactManager->FieldTypes().Find( aFieldIds[i] );

        CVPbkBaseContactFieldTypeIterator* itrNumber =

        CVPbkBaseContactFieldTypeIterator::NewLC( *myContactDataField,

                aContact->Fields() );

        // Iterate through each of the data fields

        while ( itrNumber->HasNext() )

            {

            const MVPbkBaseContactField* field = itrNumber->Next();

            if ( (field->FieldData()).DataType() == EVPbkFieldStorageTypeText )

                {

                HBufC* toAppend = MVPbkContactFieldTextData::Cast(

                        field->FieldData() ).Text().AllocL();

                aNumbers.Append( toAppend );

                }

            }

        CleanupStack::PopAndDestroy( itrNumber );

        }

    }

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

// CESMRContactHandler::LaunchRemoteLookupL

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

//

TBool CESMRContactHandler::LaunchRemoteLookupL( const TDesC& aQueryString,

                                                TDes& aDisplayname, 

                                                TDes& aEmailAddress )

    {

    FUNC_LOG;

    CPbkxRemoteContactLookupServiceUiContext::TResult result;

    DoRemoteLookupL( aQueryString, 

                     result,

                     CPbkxRemoteContactLookupServiceUiContext::EModeContactSelector);

    if ( result.iExitReason == CPbkxRemoteContactLookupServiceUiContext::TResult::EExitContactSelected )

        {

        GetNameAndEmail( aDisplayname, aEmailAddress, *(result.iSelectedContactItem) );

        return ETrue;

        }

    return EFalse;

    }

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

// CESMRContactHandler::GetLastSearchNameLC

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

//

HBufC* CESMRContactHandler::GetLastSearchNameLC( const TDesC& aEmailAddress )

    {

    FUNC_LOG;