/*

* Copyright (c) 2005-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:   CContactMatcher class implementation

*

*/

// System includes

#include <e32base.h>

#include <bamdesca.h>

#include <cntitem.h>

#include <eikenv.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <contactmatcher.h>

#include <CVPbkContactManager.h>

#include <MVPbkContactStoreList.h>

#include <MVPbkContactStore.h>

#include <CVPbkContactStoreUriArray.h>

#include <MVPbkContactLinkArray.h>

#include <MVPbkContactLink.h>

#include <MVPbkFieldType.h>

#include <MVPbkStoreContact.h>

#include <MVPbkStoreContactField.h>

#include <MVPbkStoreContactFieldCollection.h>

#include <MVPbkContactFieldData.h>

#include <MVPbkContactFieldTextData.h>

#include <MVPbkContactFieldDateTimeData.h>

#include <MVPbkContactFieldBinaryData.h>

#include <MVPbkContactOperationBase.h>

#include <MVPbkContactStoreProperties.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkContactStoreUris.h>

#include <MPbk2ContactNameFormatter.h>

#include <CVPbkFieldTypeSelector.h>

#include <TVPbkFieldVersitProperty.h>

#include <CVPbkFieldTypeRefsList.h>

#include <coemain.h>

#include <CPbk2SortOrderManager.h>

#include <Pbk2ContactNameFormatterFactory.h>

#include <msgcommonutils.rsg>

// ================= Static Constant Data ===================

typedef const TDesC& (*UriFuncPtr)();

// Number match store URIs in priority order.

// When doing number matching, order of the stores in the uri array will

// determine which stores are searched first (sequential match). We stop

// the search when first match is found.

static const UriFuncPtr NumberMatchStoreUris[] =

    {

    VPbkContactStoreUris::DefaultCntDbUri,

    // If we don't manage to open some store, we remove it from our array

    VPbkContactStoreUris::SimGlobalAdnUri,

    VPbkContactStoreUris::SimGlobalSdnUri,

    NULL,   // end marker

    };

// All store URIs except own number store

static const UriFuncPtr AllStoreUris[] =

    {

    VPbkContactStoreUris::DefaultCntDbUri,

    // If we don't manage to open some store, we remove it from our array

    VPbkContactStoreUris::SimGlobalAdnUri,

    VPbkContactStoreUris::SimGlobalSdnUri,

    VPbkContactStoreUris::SimGlobalFdnUri,

    NULL,   // end marker

    };

// Own number store URIs

static const UriFuncPtr OwnNumberStoreUris[] =

    {

    VPbkContactStoreUris::SimGlobalOwnNumberUri,

    NULL,   // end marker

    };

_LIT(KMsgCommonUtilsResourceFileName, "msgcommonutils.rsc");

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

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

// Two-phase constructor for CContactMatcher class.

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

EXPORT_C CContactMatcher* CContactMatcher::NewL(

    RFs* aFsSession )

    {

    CContactMatcher* self = CContactMatcher::NewLC( aFsSession );

    CleanupStack::Pop(self);

    return self;

    }

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

// Two-phase constructor for CContactMatcher class.

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

EXPORT_C CContactMatcher* CContactMatcher::NewLC(

    RFs* aFsSession )

    {

    CContactMatcher* self = new ( ELeave ) CContactMatcher( aFsSession );

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// C++ destructor.

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

EXPORT_C CContactMatcher::~CContactMatcher()

    {

    FreeOldOperation();

    CleanupNumberMatch();

    delete iStoreUris;

    delete iContactManager;

    delete iSortOrderManager;

    delete iNameFormatter;

    iResourceFile.Close();

    if ( iClientStatus )

        {

        User::RequestComplete( iClientStatus, KErrCancel );

        }

    if ( iASchedulerWait.IsStarted() )

        {

        iASchedulerWait.AsyncStop();

        }

    }

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

// C++ Constructor.

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

CContactMatcher::CContactMatcher( RFs* aFsSession) : iFsSession( aFsSession )

    {

    }

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

// Second phase constructor

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

void CContactMatcher::ConstructL()

    {

    iContactManager = CVPbkContactManager::NewL(

        *CVPbkContactStoreUriArray::NewLC(), iFsSession );

    CleanupStack::PopAndDestroy(); // CVPbkContactStoreUriArray

    // No stores open yet

    iStoreUris = CVPbkContactStoreUriArray::NewL();

    }

//******************* API-methods *********************************************

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

// Synchronous version

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

EXPORT_C void CContactMatcher::OpenStoreL(

    const CVPbkContactStoreUriArray& aUriArray )

    {

    InitOperationL( EOpenStore );

    OpenStoreCommonL( aUriArray );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        // Wait until stores are open

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::OpenStoreL(

    const CVPbkContactStoreUriArray& aUriArray, TRequestStatus&  aStatus )

    {

    InitOperationL( EOpenStore );

    OpenStoreCommonL( aUriArray );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }

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

// Common code to sync/async versions.

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

void CContactMatcher::OpenStoreCommonL(

    const CVPbkContactStoreUriArray& aUriArray )

    {

    if (iStoreUris->Count())

        {

        // Opening more stores when some stores are already open is not

        // supported. Support would require managing iStoreUris properly

        // so that it contains all open stores.

        User::Leave(KErrGeneral);

        }

    const TInt count = aUriArray.Count();

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

        {

        // Appended Uri:s to the array. If store fails to open it is removed

        // from the array. This keeps Uri's in priority order in the array.

        TVPbkContactStoreUriPtr uriPtr = aUriArray[i];

        iStoreUris->AppendL( uriPtr );

        iContactManager->LoadContactStoreL( uriPtr );

        }

    MVPbkContactStoreList& storeList = iContactManager->ContactStoresL();

    storeList.OpenAllL( *this );

    }

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

// Synchronous version

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

EXPORT_C void CContactMatcher::OpenAllStoresL()

    {

    OpenStoreL(AllStoreUris);

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::OpenAllStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(AllStoreUris, aStatus);

    }

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

// Synchronous version

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

EXPORT_C void CContactMatcher::OpenDefaultMatchStoresL()

    {

    OpenStoreL(NumberMatchStoreUris);

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::OpenDefaultMatchStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(NumberMatchStoreUris, aStatus);

    }

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

// Open OwnNumber stores.

// Synchronous version

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

EXPORT_C void CContactMatcher::OpenOwnNumberStoresL()

    {

    OpenStoreL(OwnNumberStoreUris);

    }

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

// Open OwnNumber stores.

// Asynchronous version

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

EXPORT_C void CContactMatcher::OpenOwnNumberStoresL( TRequestStatus& aStatus )

    {

    OpenStoreL(OwnNumberStoreUris, aStatus);

    }

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

// Close all open stores.

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

EXPORT_C void CContactMatcher::CloseStoresL()

    {

    // Closing stores does not work. MatchDataL() finds contacts from

    // closed stores.

    InitOperationL( ECloseStores );

    iApiMethodStatus = EExecuting;

    TRAPD( err, iContactManager->ContactStoresL().CloseAll( *this ) );

    iApiMethodStatus = EFinished;

    if ( err == KErrNone)

        {

        delete iStoreUris; iStoreUris = NULL;

        iStoreUris = CVPbkContactStoreUriArray::NewL();        

        }

    else

        {

        User::Leave(err);

        }

    }

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

// Synchronous version

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

EXPORT_C void CContactMatcher::MatchPhoneNumberL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags,

    CVPbkContactLinkArray& aLinkArray )

    {

    InitOperationL( EMatchPhoneNumber );

    iResultContactLinkArray = &aLinkArray;

    // Start asynchronous matching and wait until results are ready

    MatchPhoneNumberCommonL( aData, aDigits, aFlags );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::MatchPhoneNumberL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags,

    CVPbkContactLinkArray& aLinkArray, TRequestStatus& aStatus )

    {

    InitOperationL( EMatchPhoneNumber );

    iResultContactLinkArray = &aLinkArray;

    // Start asynchronous matching

    MatchPhoneNumberCommonL( aData, aDigits, aFlags );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }

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

// Common code for sync and async versions

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

void CContactMatcher::MatchPhoneNumberCommonL(

    const TDesC& aData, TInt aDigits,

    CVPbkPhoneNumberMatchStrategy::TVPbkPhoneNumberMatchFlags aFlags )

    {

    // Delete resources allocated for previous match

    CleanupNumberMatch();

    // iStoreUris is filled when stores are opened

    iStratConfig = new (ELeave) CVPbkPhoneNumberMatchStrategy::TConfig(

        aDigits,

        *iStoreUris,

        CVPbkPhoneNumberMatchStrategy::EVPbkSequentialMatch,

        aFlags);

    iMatchStrategy = CVPbkPhoneNumberMatchStrategy::NewL(

                *iStratConfig,

                *iContactManager,

                *this);

    // Start asynchronous matching

    iMatchStrategy->MatchL( aData );

    }

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

// Find from a store succeeded

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

void CContactMatcher::FindFromStoreSucceededL( MVPbkContactStore& /*aStore*/,

        MVPbkContactLinkArray* aResultsFromStore )

    {

    __ASSERT_DEBUG( aResultsFromStore, ContactMatcherPanics::Panic(

        ContactMatcherPanics::EPanNullPointer ));

    // Take the ownership of the result immediately

    CleanupDeletePushL( aResultsFromStore );

    CopyFindResultsL( aResultsFromStore );

    CleanupStack::PopAndDestroy(); // aResultsFromStore

    }

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

// Copy the found results for a store into array

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

void CContactMatcher::CopyFindResultsL( MVPbkContactLinkArray*

    aResults )

    {

    const TInt count = aResults->Count();

    if ( iResultContactLinkArray )

        {

        // Copy links to the member array

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

            {

            iResultContactLinkArray->AppendL( aResults->At( i ).CloneLC() );

            CleanupStack::Pop(); // cloned link

            }

        }

    else

        {

        iResultContactLinkCnt += count;

        }

    }

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

// Find failed

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

void CContactMatcher::FindFromStoreFailed( MVPbkContactStore& /*aStore*/, TInt /*aError*/ )

    {

    //no operation, search to continue from the other stores

    }

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

// Find complete

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

void CContactMatcher::FindFromStoresOperationComplete()

    {

    if (!iResultContactLinkArray)

        {

        // Links were not copied. Result is whether any links found or not.

        OperationComplete( iResultContactLinkCnt ? KErrNone:KErrNotFound );

        }

    else

        {

        OperationComplete();

        iResultContactLinkArray = NULL;

        }

    }

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

// Return global list of field types.

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

EXPORT_C const MVPbkFieldTypeList& CContactMatcher::FieldTypes() const

    {

    return iContactManager->FieldTypes();

    }

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

// Synchronous version

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

EXPORT_C void CContactMatcher::GetStoreContactL(

    const MVPbkContactLink& aLink, MVPbkStoreContact** aStoreContact )

    {

    InitOperationL( EGetStoreContact );

    iResultStoreContact = aStoreContact;

    // Start asynchronous operation and wait until results are ready

    FreeOldOperation();

    iOperation = iContactManager->RetrieveContactL( aLink, *this );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::GetStoreContactL(

    const MVPbkContactLink& aLink, MVPbkStoreContact** aStoreContact,

    TRequestStatus& aStatus )

    {

    InitOperationL( EGetStoreContact );

    iResultStoreContact = aStoreContact;

    // Start asynchronous operation

    FreeOldOperation();

    iOperation = iContactManager->RetrieveContactL( aLink, *this );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }

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

// Synchronous version

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

EXPORT_C void CContactMatcher::IsOwnNumberL( const TDesC& aNumber, TBool& aResult )

    {

    InitOperationL( EMatchPhoneNumber );

     // Not interested in links, only whether found or not

    iResultContactLinkArray = NULL;

    iResultContactLinkCnt = 0;

    // Start asynchronous matching and wait until results are ready

    MatchPhoneNumberCommonL( aNumber, aNumber.Length(),

        CVPbkPhoneNumberMatchStrategy::EVPbkStopOnFirstMatchFlag );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        iASchedulerWait.Start();

        }

    User::LeaveIfError( iError );

    aResult = iResultContactLinkCnt > 0;

    }

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

// Asynchronous version

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

EXPORT_C void CContactMatcher::IsOwnNumberL( const TDesC& aNumber,

    TRequestStatus& aStatus )

    {

    InitOperationL( EMatchPhoneNumber );

     // Not interested in links, only whether found or not

    iResultContactLinkArray = NULL;

    iResultContactLinkCnt = 0;

    // Start asynchronous matching

    MatchPhoneNumberCommonL( aNumber, aNumber.Length(),

        CVPbkPhoneNumberMatchStrategy::EVPbkStopOnFirstMatchFlag );

    InitOperation( &aStatus );

    if ( iApiMethodStatus != EFinished )

        {

        iApiMethodStatus = EExecuting;

        }

    }