/*

* Copyright (c) 2002-2007 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:  The contact manager for accessing different stores.

*                Initialization: a client gives an array of store URIs (Virtual

*                offers some URIs, see VPbkStoreUriLiterals.h) when creating

*                a manager. The client uses store list to open all stores.

*

*/

// INCLUDES

#include "CVPbkContactManager.h"

// Virtual Phonebook

#include "CVPbkFieldType.h"

#include "CVPbkFieldTypeList.h"

#include "CVPbkContactStoreDomainList.h"

#include "CVPbkCompositeContactView.h"

#include "CVPbkCopyContactsOperation.h"

#include "CVPbkFoldingContactView.h"

#include "CVPbkContactAttributeManager.h"

#include "MVPbkContactStoreLoader.h"

#include "VPbkCompositeContactViewFactory.h"

#include <MVPbkContactStore.h>

#include <MVPbkContactStoreProperties.h>

#include <MVPbkContactLink.h>

#include <MVPbkStoreContact.h>

#include <CVPbkContactViewDefinition.h>

#include <MVPbkContactView.h>

#include <MVPbkContactOperation.h>

#include <VPbkEng.rsg>

#include <VPbkDataCaging.hrh>

#include <CVPbkContactLinkArray.h>

#include <CVPbkContactStoreUriArray.h>

#include <CVPbkContactCopier.h>

#include <MVPbkContactOperationFactory.h>

#include <MVPbkContactOperationFactory2.h>

// System includes

#include <s32buf.h>

#include <s32mem.h>

#include <barsc.h>

#include <bautils.h>

#include <barsread.h>

#include <ecom/ecom.h>

#include <RLocalizedResourceFile.h>

#ifdef _DEBUG

namespace {

    enum TPanic

        {

        EPreCond_CreateContactViewLC,

        EUnknownViewType_CreateContactViewLC,

        ENo_Factory_Extension_FindL

        };

    void Panic( TPanic aPanic )

        {

        _LIT(KPanicCat, "CVPbkContactManager");

        User::Panic( KPanicCat, aPanic );

        }       

}

#endif // _DEBUG

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

// IsPlaceHolderCompositeView

// Returns ETrue if aViewDefinition is a composite that has no children

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

//

TBool IsPlaceHolderCompositeView( 

        const CVPbkContactViewDefinition& aViewDefinition )

    {

    return ( aViewDefinition.Type() == EVPbkCompositeView &&

             aViewDefinition.SubViewCount() == 0 );

    }

/**

 * A loader class that uses CVPbkContactManager for loading stores

 */

NONSHARABLE_CLASS(CVPbkContactManager::CContactStoreLoader) 

    :   public CBase, 

        public MVPbkContactStoreLoader

    {

    public:

        CContactStoreLoader( CVPbkContactManager& aContactManager );

    // From base class MVPbkContactStoreLoader

        MVPbkContactStoreList& ContactStoreListL() const;

        void LoadContactStoreL( const TVPbkContactStoreUriPtr& aURI );

    private:

        CVPbkContactManager& iContactManager;

    };

CVPbkContactManager::CContactStoreLoader::CContactStoreLoader( 

        CVPbkContactManager& aContactManager )

        :   iContactManager( aContactManager )

    {

    }

MVPbkContactStoreList& 

        CVPbkContactManager::CContactStoreLoader::ContactStoreListL() const

    {

    return iContactManager.ContactStoresL();

    }

void CVPbkContactManager::CContactStoreLoader::LoadContactStoreL( 

        const TVPbkContactStoreUriPtr& aURI )

    {

    iContactManager.LoadContactStoreL( aURI );

    }

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

// CVPbkContactManager::CVPbkContactManager

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

//

inline CVPbkContactManager::CVPbkContactManager( TSecurityInfo aSecurityInfo, RFs* aFs)

: iSecurityInfo( aSecurityInfo )

    {

    if (aFs)

        {

        iFs = *aFs;

        }

    }

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

// CVPbkContactManager::~CVPbkContactManager

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

//

CVPbkContactManager::~CVPbkContactManager()

    {

    delete iStoreLoader;

    delete iAttributeManager;

    delete iContactStoreDomains;

    delete iFieldTypes;

    iOwnFs.Close();

    }

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

// CVPbkContactManager::NewL

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

//

EXPORT_C CVPbkContactManager* CVPbkContactManager::NewL(

        const CVPbkContactStoreUriArray& aURIList,

        RFs* aFs /*= NULL*/)

    {

    TSecurityInfo secInfo;

    secInfo.SetToCurrentInfo();

    CVPbkContactManager* self = new(ELeave) CVPbkContactManager( secInfo, aFs);

    CleanupStack::PushL(self);

    self->ConstructL(aURIList);

    CleanupStack::Pop(self);

    return self;

    }

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

// CVPbkContactManager::NewL

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

//

EXPORT_C CVPbkContactManager* CVPbkContactManager::NewL(

        TSecurityInfo aSecurityInfo,

        const CVPbkContactStoreUriArray& aURIList,

        RFs* aFs /*= NULL*/)

    {

    CVPbkContactManager* self = new(ELeave) CVPbkContactManager( aSecurityInfo, aFs);

    CleanupStack::PushL(self);

    self->ConstructL(aURIList);

    CleanupStack::Pop(self);

    return self;

    }

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

// CVPbkContactManager::ConstructL

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

//

inline void CVPbkContactManager::ConstructL

        (const CVPbkContactStoreUriArray& aURIList)

    {

    if (iFs.Handle() == KNullHandle)

        {

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

        iFs = iOwnFs;

        }

    VPbkEngUtils::RLocalizedResourceFile resFile;

    resFile.OpenLC( iFs, KVPbkRomFileDrive,

        KDC_RESOURCE_FILES_DIR, KVPbkDefResFileName );

    HBufC8* fieldTypesBuf = resFile.AllocReadLC(R_VPBK_GLOBAL_FIELD_TYPES);

    TResourceReader resReader;

    resReader.SetBuffer(fieldTypesBuf);

    iFieldTypes = CVPbkFieldTypeList::NewL(resFile, resReader);

    CleanupStack::PopAndDestroy(2, &resFile);

    iContactStoreDomains =

        CVPbkContactStoreDomainList::NewL( aURIList, *iFieldTypes, iSecurityInfo );

    iStoreLoader = new( ELeave ) CContactStoreLoader( *this );

    }

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

// CVPbkContactManager::FieldTypes

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

//

EXPORT_C const MVPbkFieldTypeList& CVPbkContactManager::FieldTypes() const

    {

    return *iFieldTypes;

    }

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

// CVPbkContactManager::ContactStoresL

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

//

EXPORT_C MVPbkContactStoreList& CVPbkContactManager::ContactStoresL()

    {

    return *iContactStoreDomains;

    }

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

// CVPbkContactManager::LoadContactStoreL

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

//

EXPORT_C void CVPbkContactManager::LoadContactStoreL

        (const TVPbkContactStoreUriPtr& aURI)

    {

    if (!iContactStoreDomains->Find(aURI))

        {

        CVPbkContactStoreUriArray* uriList = CVPbkContactStoreUriArray::NewLC();

        uriList->AppendL(aURI);

        iContactStoreDomains->LoadPluginStoreDomainsL( *uriList, *iFieldTypes, 

                                                       iSecurityInfo );

        CleanupStack::PopAndDestroy(); // uriList

        }

    }

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

// CVPbkContactManager::ContactAttributeManagerL

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

//

EXPORT_C MVPbkContactAttributeManager&

        CVPbkContactManager::ContactAttributeManagerL()

    {

    if (!iAttributeManager)

        {

        iAttributeManager = CVPbkContactAttributeManager::NewL(*this);

        }

    return *iAttributeManager;

    }

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

// CVPbkContactManager::CreateContactViewLC

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

//

EXPORT_C MVPbkContactViewBase* CVPbkContactManager::CreateContactViewLC(

        MVPbkContactViewObserver& aObserver,

        const CVPbkContactViewDefinition& aViewDefinition, 

        const MVPbkFieldTypeList& aSortOrder) const

    {

    MVPbkContactViewBase* result = NULL;

    switch ( aViewDefinition.Type() )

        {

        case EVPbkContactsView: // FALLTHROUGH

        case EVPbkGroupsView:

            {

            // Create a leaf view from the store plug-in.

            MVPbkContactStore* store = FindStore( aViewDefinition.Uri() );

            if ( !store )

                {

                User::Leave( KErrNotFound );

                }

            result = store->CreateViewLC( aViewDefinition, aObserver, 

                aSortOrder );

            break;

            }

        case EVPbkFoldingView:

            {

            // Create a folding view. Folding view can then

            // be expanded to its subviews.

            result = CVPbkFoldingContactView::NewLC( aObserver, 

                aViewDefinition, *this, aSortOrder ); 

            break;

            }

        case EVPbkCompositeView:

            {

            result = CreateOptimizedCompositeViewLC( aObserver,

                    aViewDefinition, aSortOrder );

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse, Panic ( EUnknownViewType_CreateContactViewLC ));

            CleanupStack::PushL( result ); // LC semantics

            break;

            }

        }

    return result;

    }

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

// CVPbkContactManager::RetrieveContactL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::RetrieveContactL(

        const MVPbkContactLink& aLink,

        MVPbkSingleContactOperationObserver& aObserver) const

    {

    MVPbkContactOperation* operation = 

        iContactStoreDomains->CreateContactRetrieverL( aLink, aObserver );

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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

// CVPbkContactManager::CreateLinksLC

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

//

EXPORT_C MVPbkContactLinkArray* CVPbkContactManager::CreateLinksLC(

        const TDesC8& aPackedLinks) const

    {

    RDesReadStream readStream( aPackedLinks );

    readStream.PushL();

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC(

        readStream, *iStoreLoader );

    CleanupStack::Pop( linkArray );

    CleanupStack::PopAndDestroy( &readStream );

    CleanupStack::PushL( linkArray );

    return linkArray;    

    }

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

// CVPbkContactManager::CreateLinksLC

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

//

EXPORT_C MVPbkContactLinkArray* CVPbkContactManager::CreateLinksLC(

        RReadStream& aStream) const

    {    

    CVPbkContactLinkArray* linkArray = CVPbkContactLinkArray::NewLC(

        aStream, *iStoreLoader );

    return linkArray;

    }

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

// CVPbkContactManager::DeleteContactsL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::DeleteContactsL(

        const MVPbkContactLinkArray& aContactLinks, 

        MVPbkBatchOperationObserver& aObserver)

    {

    MVPbkContactOperation* operation = 

        iContactStoreDomains->CreateDeleteContactsOperationL(

            aContactLinks, aObserver);

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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

// CVPbkContactManager::CommitContactsL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::CommitContactsL(

        const TArray<MVPbkStoreContact*>& aContacts, 

        MVPbkBatchOperationObserver& aObserver)

    {

    MVPbkContactOperation* operation =

        iContactStoreDomains->CreateCommitContactsOperationL(

            aContacts, aObserver);

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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

// CVPbkContactManager::CopyContactsL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::CopyContactsL(

        const MVPbkContactLinkArray& aContactLinks,

        MVPbkContactStore* aTargetStore,

        MVPbkBatchOperationObserver& aObserver)

    {

    MVPbkContactOperation* operation = CVPbkCopyContactsOperation::NewLC(

            CVPbkContactCopier::EVPbkSimpleContactCopy,

            *this,

            aContactLinks,

            aTargetStore,

            NULL,

            aObserver);

    operation->StartL();

    CleanupStack::Pop(); // operation

    return operation;

    }

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

// CVPbkContactManager::MatchPhoneNumberL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::MatchPhoneNumberL(

        const TDesC& aPhoneNumber, 

        TInt aMaxMatchDigits,

        MVPbkContactFindObserver& aObserver)

    {

    MVPbkContactOperation* operation = 

        iContactStoreDomains->CreateMatchPhoneNumberOperationL(

            aPhoneNumber, aMaxMatchDigits, aObserver);

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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

// CVPbkContactManager::FindL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::FindL(

        const TDesC& aSearchString,

        const MVPbkFieldTypeList& aFieldTypes,

        MVPbkContactFindObserver& aObserver)

    {

     MVPbkContactOperation* operation = 

     (static_cast<MVPbkContactOperationFactory*>(iContactStoreDomains))->CreateFindOperationL(

            aSearchString, aFieldTypes, aObserver); 

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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

// CVPbkContactManager::FindL

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

//

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::FindL(

        const MDesC16Array& aSearchStrings, 

        const MVPbkFieldTypeList& aFieldTypes, 

        MVPbkContactFindFromStoresObserver& aObserver, 

        const TCallBack& aWordParserCallBack )

    {

     MVPbkContactOperation* operation = 

     (static_cast<MVPbkContactOperationFactory*>(iContactStoreDomains))->CreateFindOperationL(

            aSearchStrings, aFieldTypes, aObserver, aWordParserCallBack ); 

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

EXPORT_C MVPbkContactOperationBase* CVPbkContactManager::FindL(

        const MDesC16Array& aSearchStrings, 

        const MVPbkFieldTypeList& aFieldTypes, 

        MVPbkContactFindFromStoresObserver& aObserver, 

        const TCallBack& aWordParserCallBack, const CDesC16ArrayFlat& aStoreEntriesArray )

 {

    MVPbkContactOperation* operation = NULL;

    MVPbkContactOperationFactory2* factoryExtension = reinterpret_cast<MVPbkContactOperationFactory2*>

    	(iContactStoreDomains->ContactOperationFactoryExtension(KMVPbkContactOperationFactory2Uid) );

    // Safeguard to avoid factory extension initialization. It is a programming error if 

    // factory extension does not exist.

    __ASSERT_DEBUG(factoryExtension, Panic( ENo_Factory_Extension_FindL ) );

    operation = 

        factoryExtension->CreateFindOperationL(

            aSearchStrings, aFieldTypes, aObserver, aWordParserCallBack ,aStoreEntriesArray );

    if (operation)

        {

        CleanupDeletePushL(operation);

        operation->StartL();

        CleanupStack::Pop(); // operation

        }

    return operation;

    }

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