/*

* Copyright (c) 2006 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:   Searches contact using email address as search filter from address books.

*

*/

#include "MuiuContactAddressMatcher.h"

#include <data_caging_path_literals.hrh>    // KDC_RESOURCE_FILES_DIR

#include <muiu_internal.rsg>                // R_MUIU_PHONENUMBER_MATCH_INTEREST

#include <eikenv.h>

#include <coemain.h>

#include <basched.h>                        // KLeaveExit

#include <bautils.h>                        // BaflUtils

#include <contactmatcher.h>

#include <CVPbkContactManager.h>

#include <CVPbkContactLinkArray.h>

#include <MVPbkStoreContact.h>

#include <CVPbkFieldTypeSelector.h>

#include <VPbkContactViewFilterBuilder.h>

#include <MVPbkContactFieldTextData.h>

#include <CVPbkFieldTypeRefsList.h>

#include <TVPbkFieldVersitProperty.h>

#include <AiwServiceHandler.h>

#include <finditemmenu.h>

#include <e32base.h>

#include <AknWaitDialog.h>

#include <aknnotewrappers.h>        // CAknInformationNote

#include <StringLoader.h>

#include "MuiuMsvUiServiceUtilities.h"

// Constants 

// Resource file

_LIT( KMuiuInternalResourceFileName, "muiu_internal.rsc" );

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

// CMuiuContactAddressMatcher::NewL

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

//

CMuiuContactAddressMatcher* CMuiuContactAddressMatcher::NewL(

    CEikonEnv& aEikonEnv )

    {

    CMuiuContactAddressMatcher* self =

        new( ELeave ) CMuiuContactAddressMatcher( aEikonEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMuiuContactAddressMatcher::CMuiuContactAddressMatcher

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

//

CMuiuContactAddressMatcher::CMuiuContactAddressMatcher( 

        CEikonEnv& aEikonEnv ):

    CActive( EPriorityStandard ),

    iEikEnv( aEikonEnv ),

    iResourceOffset( KErrNotFound )

    {

    CActiveScheduler::Add( this );

    }

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

// CMuiuContactAddressMatcher::ConstructL

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

//

inline void CMuiuContactAddressMatcher::ConstructL()

    {

	iServiceHandler = CAiwServiceHandler::NewL();    

    iContactMatcher = CContactMatcher::NewL( &iEikEnv.FsSession() );

    //Changed to open only default stores.

    //Opening of all stores caused

    //frequent jamming.

    iContactMatcher->OpenDefaultMatchStoresL();

    iContactLinks = CVPbkContactLinkArray::NewL();

    iChangedLinks = CVPbkContactLinkArray::NewL();

    //Idle object is needed because we can't

    //call callback method straight from HandleNotifyL().

    //It causes KErrInUse leave.

    iIdle = CIdle::NewL(CActive::EPriorityIdle);

    if ( !iEikEnv.IsResourceAvailableL( R_MUIU_PHONENUMBER_MATCH_INTEREST ) )

        {

        TFileName fileName;

        TParse parse;

        parse.Set( KMuiuInternalResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL );

        fileName = parse.FullName();

        BaflUtils::NearestLanguageFile( iEikEnv.FsSession(), fileName );

        iResourceOffset = iEikEnv.AddResourceFileL( fileName );

        }

    iServiceHandler->AttachL( R_MUIU_PHONENUMBER_MATCH_INTEREST );    

    }

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

// CMuiuContactAddressMatcher::~CMuiuContactAddressMatcher

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

//

CMuiuContactAddressMatcher::~CMuiuContactAddressMatcher()

    {

    Cancel();

    // delete link arrays first to avoid access violations:

    delete iContactLinks;   

    delete iChangedLinks;    

    // doesn't matter really if detaching fails

    if( iServiceHandler )

        {

        TRAP_IGNORE( iServiceHandler->DetachL( R_MUIU_PHONENUMBER_MATCH_INTEREST ) ); 

        } 

    delete iContactMatcher;

    delete iIdle;   

    delete iServiceHandler;

    if ( iResourceOffset != KErrNotFound )

        {

        iEikEnv.DeleteResourceFile( iResourceOffset );

        }

    } 

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

// CMuiuContactAddressMatcher::FindContactL

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

//

TBool CMuiuContactAddressMatcher::FindContactL(

    const TDesC& aMailAddress,

    TCallBack aCallBack )

    {

    if ( !MsvUiServiceUtilities::IsValidEmailAddressL( aMailAddress ) )

        {

        return  EFalse;

        }

    if ( !IsActive() )         

        {        

        iCallBack = aCallBack;

        // reset old data

        iContactLinks->ResetAndDestroy();

        iChangedLinks->ResetAndDestroy();        

        const MVPbkFieldTypeList& fieldTypes = iContactMatcher->FieldTypes();         

        iContactMatcher->MatchDataL( aMailAddress, 

                                     fieldTypes, 

                                     *iContactLinks,

                                     iStatus );  

        SetActive();

        // dialog sets iWaitDialog to NULL when it gets deleted

        if (!iWaitDialog )

            {

            iWaitDialog = new( ELeave ) CAknWaitDialog(

                ( REINTERPRET_CAST( CEikDialog**, &iWaitDialog ) ), ETrue );

            }

        iWaitDialog->ExecuteLD( R_MUIU_MATCHING_ADDRESS_WAIT_NOTE );

        }

    else

        {

        User::Leave( KErrInUse );

        }

    return ETrue;

    }    

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

// CMuiuContactAddressMatcher::GetAddressL()

// Returns NULL pointer if no data is found

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

HBufC* CMuiuContactAddressMatcher::GetAddressL() const

    {

    ASSERT( !IsActive() );

    HBufC* text( NULL );

    if ( iChangedLinks->Count() > 0 )

        {

        ASSERT( iChangedLinks->Count() == 1 ); // single item fetch -> 1

        MVPbkStoreContact* storeContact = NULL;

        MVPbkStoreContactField* selectedField = NULL;        

        const MVPbkContactLink& link = iChangedLinks->At( 0 );

        iContactMatcher->GetStoreContactL( link, &storeContact ); 

        storeContact->PushL();   

        MVPbkStoreContactFieldCollection& fieldCollection =

            storeContact->Fields();

        selectedField = fieldCollection.RetrieveField( link ); 

        if ( selectedField )

            {

            // Set field data

            const MVPbkContactFieldTextData* textData =

                &MVPbkContactFieldTextData::Cast( selectedField->FieldData() );

            text = textData->Text().AllocL();

            }

        CleanupStack::PopAndDestroy( storeContact );

        }        

    iChangedLinks->ResetAndDestroy();        

    return text;

    }

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

// CMuiuContactAddressMatcher::GetNameL()

// Returns NULL pointer if no data is found

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

HBufC* CMuiuContactAddressMatcher::GetNameL() const

    {

    MVPbkStoreContact* storeContact = NULL;

    HBufC* name( NULL );

    ASSERT(iContactMatcher); // should exist

    if(iContactLinks->Count() > 0)

        {

        //We should have only one contact link.

        iContactMatcher->GetStoreContactL( iContactLinks->At(0), &storeContact ); 

        storeContact->PushL();   

        MVPbkStoreContactFieldCollection& fieldCollection =

            storeContact->Fields();

        name = iContactMatcher->GetNameL(fieldCollection);

        CleanupStack::PopAndDestroy( storeContact );

        }

    iContactLinks->ResetAndDestroy();    

    return name;

    }       

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

// CMuiuContactAddressMatcher::DoCancel()

// From CActive

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

//

void CMuiuContactAddressMatcher::DoCancel()

    {

    if ( iContactMatcher )

        {

        iContactMatcher->CancelOperation();

        }

    }

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

// CMuiuContactAddressMatcher::RunL()

// From CActive

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

//

void CMuiuContactAddressMatcher::RunL()

    {        

    // We need to delete excess matches, otherwise Fetch AIW may

    // continue with next match when user presses Cancel.

    DeleteExcessMatchesL( *iContactLinks );

    if( iContactLinks->Count() == 0)

        {

        HBufC* string = StringLoader::LoadLC( R_MUIU_QTN_PHOB_NOTE_NO_NUMBER, &iEikEnv );

        CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue );

        note->ExecuteLD( *string );

        CleanupStack::PopAndDestroy( string ); 

        // Deleting wait dialog in the beginning of the function causes

        // info note to flicker

        if ( iWaitDialog )

            {

            iWaitDialog->ProcessFinishedL(); // deletes the dialog

            }

        //We can't call iCallBack straight away,

        //because it triggers events that cause KErrInUse leave.

        iIdle->Start(iCallBack);

        }

    else

        {

        if ( iWaitDialog )

            {

            iWaitDialog->ProcessFinishedL(); // deletes the dialog

            }

        CVPbkFieldTypeSelector* filter = CreateFilterLC( );

        TAiwSingleItemSelectionDataV3 selectionData = SelectionData( *filter);        

        ExecuteSingleItemFetchL( selectionData, *iContactLinks );    

        CleanupStack::PopAndDestroy( filter );

        }

    }

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

// CMuiuContactAddressMatcher::RunError

// From CActive

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

//

TInt CMuiuContactAddressMatcher::RunError( TInt aError )

    {      

    if( aError == KLeaveExit )

        {

        return aError;    

        }

    else

        {

        return KErrNone;

        }

    }

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

// CMuiuContactAddressMatcher::HandleNotifyL

// From MAiwNotifyCallback

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

//

TInt CMuiuContactAddressMatcher::HandleNotifyL(

    TInt /*aCmdId*/,

    TInt aEventId,

    CAiwGenericParamList& aEventParamList,

    const CAiwGenericParamList& /*aInParamList*/ )

    {

    TInt retVal( KErrNone );

    if ( aEventId == KAiwEventCompleted )

        {

        TInt index( 0 );

        const TAiwGenericParam* param =

            aEventParamList.FindFirst( index, EGenericParamContactLinkArray );

        if ( param )

            {

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

            if ( contactLinks.Length() > 0 )

                {

                CVPbkContactLinkArray* links = CVPbkContactLinkArray::NewLC(

                    contactLinks, iContactMatcher->GetContactStoresL() );

                CleanupStack::Pop();//links

                iChangedLinks->ResetAndDestroy();

                delete iChangedLinks;

                iChangedLinks = links;

                }

            else

                {

                retVal = KErrArgument;    

                }

            } 

        }

    //Notify waiter always, even if error.

    //We can't call iCallBack straight away,

    //because it triggers events that cause KErrInUse leave.

    iIdle->Start(iCallBack);

    return retVal;

    }

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

//  CMuiuContactAddressMatcher::DeleteExcessMatches()

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

void CMuiuContactAddressMatcher::DeleteExcessMatchesL(

    CVPbkContactLinkArray& aLinks ) const

    {

    // It may be that first contact has not phone number but others has.

    TInt count = aLinks.Count();

    // Search for first contact that has phone number

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

        {

        MVPbkStoreContact* storeContact = NULL;

        const MVPbkContactLink& link = aLinks.At( i );

        iContactMatcher->GetStoreContactL( link, &storeContact ); 

        storeContact->PushL();   

        if (    storeContact

            &&  iContactMatcher->ContactHasFieldOfTypeL( EAiwPhoneNumberSelect, *storeContact ) == KErrNotFound )

            {

            aLinks.Delete( i-- );

            count = aLinks.Count();

            }

        else if ( !storeContact )

            {

            // is this possible?

            aLinks.Delete( i-- );

            count = aLinks.Count();

            }

        else

            {

            CleanupStack::PopAndDestroy( storeContact );

            break;

            }

        CleanupStack::PopAndDestroy( storeContact );

        }

    TInt k( aLinks.Count() - 1 );

    // delete all but link at index 0

    while ( k > 0 )

        {

        aLinks.Delete( k-- );

        }

    }

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

//  CMuiuContactAddressMatcher::CreateFilterLC()

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

CVPbkFieldTypeSelector* CMuiuContactAddressMatcher::CreateFilterLC( ) const

    {

    CVPbkContactManager& contactMgr = iContactMatcher->GetContactManager();

    CVPbkFieldTypeSelector* contactViewFilter =

        CVPbkFieldTypeSelector::NewL( contactMgr.FieldTypes() );

    CleanupStack::PushL( contactViewFilter );

    // Append the filter object with suitable criteria

    VPbkContactViewFilterBuilder::BuildContactViewFilterL(

        *contactViewFilter, EVPbkContactViewFilterPhoneNumber, contactMgr );

    //VPbkContactViewFilterBuilder::BuildContactViewFilterL(

    //    *contactViewFilter, EVPbkContactViewFilterEmail, contactMgr );

    return contactViewFilter;

    }

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

//  CMuiuContactAddressMatcher::SelectionData()

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

TAiwSingleItemSelectionDataV3

CMuiuContactAddressMatcher::SelectionData(

    CVPbkFieldTypeSelector& aFilter ) const

    {

    TAiwAddressSelectType addressSelectType( EAiwAllItemsSelect );

    addressSelectType = EAiwPhoneNumberSelect;

    TAiwSingleItemSelectionDataV3 selData;

    selData.SetAddressSelectType( addressSelectType )

           .SetFetchFilter( &aFilter );

    return selData;

    }

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

//  CMuiuContactAddressMatcher::ExecuteSingleItemFetchL()

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

void CMuiuContactAddressMatcher::ExecuteSingleItemFetchL( 

    TAiwSingleItemSelectionDataV3 aData,

    const CVPbkContactLinkArray& aLinks )

    {

    CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();    

    inParamList.AppendL(

        TAiwGenericParam( EGenericParamContactSelectionData,

        TAiwVariant( TAiwSingleItemSelectionDataV3Pckg( aData ) ) ) );

    //Contacts that matched search

    HBufC8* packedLinks = aLinks.PackLC();

    inParamList.AppendL( TAiwGenericParam( EGenericParamContactLinkArray,

                                           TAiwVariant( *packedLinks ) ) );

    iServiceHandler->ExecuteServiceCmdL( KAiwCmdSelect, 

                                        inParamList, 

                                        iServiceHandler->OutParamListL(),

                                        0,

                                        this );

    CleanupStack::PopAndDestroy( packedLinks ); 

    }

// End of File