/*

* 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:  Contacts Model store contact store implementation.

*

*/

// INCLUDES

#include "CContactStore.h"

// VPbkCntModel

#include "CFieldFactory.h"

#include "CFieldTypeMap.h"

#include "CAsyncContactOperation.h"

#include "CContact.h"

#include "CContactLink.h"

#include "CContactBookmark.h"

#include "CContactView.h"

#include "CFilteredContactView.h"

#include "CFilteredGroupView.h"

#include "CGroupView.h"

#include "CContactStoreDomain.h"

#include "CFieldInfo.h"

#include "CContactRetriever.h"

#include "CDeleteContactsOperation.h"

#include "CCommitContactsOperation.h"

#include "CMatchPhoneNumberOperation.h"

#include "CFindOperation.h"

#include "CFindInTextDefOperation.h"

#include "CContactStoreInfo.h"

#include "CVPbkDiskSpaceCheck.h"

#include "CNamedRemoteViewHandle.h"

#include "CSortOrderAcquirerList.h"

#include "VoiceTagSupport.h"

#include "CContactLink.h"

#include "COwnContactLinkOperation.h"

#include <VPbkCntModelRes.rsg>

// Virtual Phonebook

#include <VPbkError.h>

#include <MVPbkContactStoreObserver.h>

#include <TVPbkContactStoreUriPtr.h>

#include <CVPbkContactStoreUri.h>

#include <CVPbkAsyncOperation.h>

#include <RLocalizedResourceFile.h>

#include <CVPbkAsyncCallback.h>

#include <CVPbkContactViewDefinition.h>

#include <VPbkContactView.hrh>

#include <CVPbkContactStoreProperties.h>

#include <CVPbkLocalVariationManager.h>

#include <CVPbkFieldTypeSelector.h>

#include <VPbkUtils.h>

#include <TVPbkContactStoreUriPtr.h>

#include <VPbkDataCaging.hrh>

#include <VPbkContactStoreUris.h>

#include <MVPbkSingleContactLinkOperationObserver.h>

// Contacts Model

#include <cntdb.h>

#include <cntitem.h>

#include <cntmodel.rsg>

// System includes

#include <barsc.h>

#include <barsread.h>

#include <featmgr.h>

#include <shareddataclient.h>

#include <coemain.h>

// Debugging headers

#include <VPbkDebug.h>

namespace VPbkCntModel {

#ifdef _DEBUG

_LIT( KContactStorePanicCat, "VPbkCntModel_CContactStore" );

void ContactStorePanic( TContactStorePanic aPanic )

	{

	User::Panic( KContactStorePanicCat, aPanic);

	}

#endif // _DEBUG

/// Unnamed namespace for local definitions

namespace {

// LOCAL

_LIT(KCntResFile, "cntmodel.rsc");

_LIT(KCntExtResFile, "VPbkCntModelRes.rsc");

// CONSTANTS

const TInt KDefaultArrayGranularity = 4;

const TInt KDiskSpaceForDbOpening = 140 * 1024; // 140 kB space for db opening

inline void SendEventL(MVPbkContactStoreObserver* aObserver,

                       void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&),

                       MVPbkContactStore& aStore)

    {

    (aObserver->*aEventFunc)(aStore);

    }

inline void SendEventL(

        MVPbkContactStoreObserver* aObserver,

        void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&,TVPbkContactStoreEvent),

        MVPbkContactStore& aStore,

        TVPbkContactStoreEvent aEvent)

    {

    (aObserver->*aEventFunc)(aStore, aEvent);

    }

inline void SendErrorEvent(MVPbkContactStoreObserver* aObserver,

                           void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&,TInt),

                           MVPbkContactStore& aStore, TInt aError)

    {

    (aObserver->*aEventFunc)(aStore, aError);

    }

void SendEventL

        (RPointerArray<MVPbkContactStoreObserver>& aObservers,

        void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&),

        MVPbkContactStore& aStore)

    {

    for (TInt i = aObservers.Count() - 1; i >= 0; --i)

        {

        SendEventL(aObservers[i], aEventFunc, aStore);

        }

    }

void SendEventL

        (RPointerArray<MVPbkContactStoreObserver>& aObservers,

        void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&,TVPbkContactStoreEvent),

        MVPbkContactStore& aStore,

        TVPbkContactStoreEvent aEvent)

    {

    for (TInt i = aObservers.Count() - 1; i >= 0; --i)

        {

        SendEventL(aObservers[i], aEventFunc, aStore, aEvent);

        }

    }

void SendErrorEvent

        (RPointerArray<MVPbkContactStoreObserver>& aObservers,

        void (MVPbkContactStoreObserver::*aEventFunc)(MVPbkContactStore&,TInt),

        MVPbkContactStore& aStore, TInt aError)

    {

    for (TInt i = aObservers.Count() - 1; i >= 0; --i)

        {

        SendErrorEvent(aObservers[i], aEventFunc, aStore, aError);

        }

    }

TBool UpdateSystemTemplateFieldL(CContactItem& aSystemTemplate,

        const CFieldInfo& aFieldInfo )

    {

    TBool updated = EFalse;

    // Scan system template field set for the field

    CContactItemFieldSet& fieldSet = aSystemTemplate.CardFields();

    const TInt fieldCount = fieldSet.Count();

    TInt i = 0;

    for (; i < fieldCount; ++i)

        {

        CContactItemField& sysTemplateField = fieldSet[i];

        if (aFieldInfo.IsEqualType(sysTemplateField))

            {

            // Field was found, just check the label

            if (!aFieldInfo.IsEqualLabel(sysTemplateField))

                {

                sysTemplateField.SetLabelL(aFieldInfo.FieldName());

                updated = ETrue;

                }

            break;

            }

        }

    if ( i == fieldCount )

        {

        // Field was not found, add it

        CContactItemField* field = aFieldInfo.CreateFieldL();

        CleanupStack::PushL( field );

        fieldSet.AddL( *field );

        CleanupStack::Pop( field );

        updated = ETrue;

        }

    return updated;

    }

TBool UpdateSystemTemplateFieldsL(CContactItem& aSystemTemplate, const CFieldsInfo& aFieldsInfo)

    {

    TBool updated = EFalse;

    const TInt fieldInfoCount = aFieldsInfo.Count();

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

        {

        if (UpdateSystemTemplateFieldL(aSystemTemplate, *aFieldsInfo.At(i)))

            {

            updated = ETrue;

            }

        }

    return updated;

    }

TVPbkContactStoreEvent MapDbEventToStoreEvent(TContactDbObserverEvent aEvent)

    {

    TVPbkContactStoreEvent result(TVPbkContactStoreEvent::ENullEvent, NULL);

    switch (aEvent.iType)

        {

        case EContactDbObserverEventContactAdded:

            {

            result.iEventType = TVPbkContactStoreEvent::EContactAdded;

            break;

            }

        case EContactDbObserverEventContactDeleted:

        case EContactDbObserverEventOwnCardDeleted:

            {

            result.iEventType = TVPbkContactStoreEvent::EContactDeleted;

            break;

            }

	    case EContactDbObserverEventContactChanged:

	    case EContactDbObserverEventSpeedDialsChanged:

        case EContactDbObserverEventOwnCardChanged:

            {

            result.iEventType = TVPbkContactStoreEvent::EContactChanged;

            break;

            }

	    case EContactDbObserverEventGroupAdded:

            {

            result.iEventType = TVPbkContactStoreEvent::EGroupAdded;

            break;

            }

        case EContactDbObserverEventGroupDeleted:

            {

            result.iEventType = TVPbkContactStoreEvent::EGroupDeleted;

            break;

            }

        case EContactDbObserverEventGroupChanged:

            {

            result.iEventType = TVPbkContactStoreEvent::EGroupChanged;

            break;

            }

	    case EContactDbObserverEventUnknownChanges:

            {

            result.iEventType = TVPbkContactStoreEvent::EUnknownChanges;

            break;

            }

	    case EContactDbObserverEventBackupBeginning:

            {

            result.iEventType = TVPbkContactStoreEvent::EStoreBackupBeginning;

            break;

            }

	    case EContactDbObserverEventRestoreBeginning:

            {

            result.iEventType = TVPbkContactStoreEvent::EStoreRestoreBeginning;

            break;

            }

	    case EContactDbObserverEventBackupRestoreCompleted:

            {

            result.iEventType = TVPbkContactStoreEvent::EStoreBackupRestoreCompleted;

            break;

            }

        case EContactDbObserverEventCurrentItemDeleted:         // FALLTHROUGH

	    case EContactDbObserverEventCurrentItemChanged:         // FALLTHROUGH

	    case EContactDbObserverEventCurrentDatabaseChanged:     // FALLTHROUGH

	    case EContactDbObserverEventRestoreBadDatabase:         // FALLTHROUGH

	    case EContactDbObserverEventSortOrderChanged:           // FALLTHROUGH

	    case EContactDbObserverEventPreferredTemplateChanged:   // FALLTHROUGH

	    case EContactDbObserverEventRecover:                    // FALLTHROUGH

	    case EContactDbObserverEventRollback:                   // FALLTHROUGH

	    case EContactDbObserverEventTablesClosed:               // FALLTHROUGH

	    case EContactDbObserverEventTablesOpened:               // FALLTHROUGH

	    case EContactDbObserverEventTemplateChanged:            // FALLTHROUGH

	    case EContactDbObserverEventTemplateDeleted:            // FALLTHROUGH

	    case EContactDbObserverEventTemplateAdded:              // FALLTHROUGH

        case EContactDbObserverEventNull:                       // FALLTHROUGH

	    case EContactDbObserverEventUnused:                     // FALLTHROUGH

        default:

            {

            result.iEventType = TVPbkContactStoreEvent::ENullEvent;

            break;

            }

        }

    return result;

    }

}  // unnamed namespace

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

// CContactStore::CContactStore

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

//

CContactStore::CContactStore( CContactStoreDomain& aStoreDomain ) :

        iStoreDomain( aStoreDomain )

    {

    }

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

// CContactStore::~CContactStore

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

//

CContactStore::~CContactStore()

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

        ("CContactStore::~CContactStore(0x%x)"), this);

    iNamedViewContainer.ResetAndDestroy();

    CloseSystemTemplate(iContactDb);

    iObservers.Close();

    delete iStoreInfo;

    delete iDbNotifier;

    delete iContactDb;

    delete iAsyncContactOperation;

    delete iAsyncOpenOp;

    delete iStoreURI;

    delete iFieldFactory;

    delete iFieldsInfo;

    delete iProperties;

    delete iDiskSpaceCheck;

    FeatureManager::UnInitializeLib();

    }

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

// CContactStore::NewL

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

//

CContactStore* CContactStore::NewL

        (const TVPbkContactStoreUriPtr& aURI,

        CContactStoreDomain& aStoreDomain)

    {

    CContactStore* self = new(ELeave) CContactStore(aStoreDomain);

    CleanupStack::PushL(self);

    self->ConstructL(aURI);

    CleanupStack::Pop(self);

    return self;

    }

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

// CContactStore::ConstructL

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

//

inline void CContactStore::ConstructL(

        const TVPbkContactStoreUriPtr& aURI)

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

        ("CContactStore::ConstructL(%S)"), &aURI.UriDes());

    FeatureManager::InitializeLibL();

    iProperties = CVPbkContactStoreProperties::NewL();

    iStoreURI = CVPbkContactStoreUri::NewL(aURI);

    iProperties->SetName(iStoreURI->Uri());

    // open and read the contacts model resource file cntmodel.rsc

    VPbkEngUtils::RLocalizedResourceFile resFile;

    resFile.OpenLC(iStoreDomain.FsSession(),

        KVPbkRomFileDrive, KDC_CONTACTS_RESOURCE_DIR, KCntResFile);

    TResourceReader reader;

    reader.SetBuffer( resFile.AllocReadLC(R_CNTUI_NEW_FIELD_DEFNS) );

    // create the fields info structure from the contacts model fields

    iFieldsInfo = CFieldsInfo::NewL(reader);

    CleanupStack::PopAndDestroy(2); // R_CNTUI_NEW_FIELD_DEFNS buffer, resFile

    // Extend the contacts model golden template with variant fields

    DoAddFieldTypesL();

    iAsyncOpenOp =

        CVPbkAsyncObjectOperation<MVPbkContactStoreObserver>::NewL();

    iAsyncContactOperation = CAsyncContactOperation::NewL(*this);

    iStoreInfo = CContactStoreInfo::NewL(*this, iStoreDomain);

    // Get contact store location drive for disk space check

    const TPtrC ptr( iStoreURI->Uri().Component

        ( TVPbkContactStoreUriPtr::EContactStoreUriStoreDrive ) );

    TInt drive( EDriveA ); // c is usually the default location

    User::LeaveIfError( iStoreDomain.FsSession().CharToDrive

        ( ptr[0], drive) );

    iDiskSpaceCheck = VPbkEngUtils::CVPbkDiskSpaceCheck::NewL

            ( iStoreDomain.FsSession(), drive );

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

        ("CContactStore::ConstructL end"));

    }

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

// CContactStore::FieldTypeMap

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

//

const CFieldTypeMap& CContactStore::FieldTypeMap() const

    {

    return iStoreDomain.FieldTypeMap();

    }

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

// CContactStore::FieldFactory

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

//

const CFieldFactory& CContactStore::FieldFactory() const

    {

    return *iFieldFactory;

    }

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

// CContactStore::MasterFieldTypeList

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

//

const MVPbkFieldTypeList& CContactStore::MasterFieldTypeList() const

    {

    return iStoreDomain.MasterFieldTypeList();

    }

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

// CContactStore::CreateFieldLC

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

//

CContactItemField* CContactStore::CreateFieldLC

        (const MVPbkFieldType& aFieldType) const

    {

    return iFieldFactory->CreateFieldLC(aFieldType);

    }

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

// CContactStore::ReadContactL

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

//

void CContactStore::ReadContactL

        (TContactItemId aContactId, MVPbkContactObserver& aObserver)

    {

    iAsyncContactOperation->PrepareL

        (MVPbkContactObserver::EContactRead, aContactId, aObserver);

    iAsyncContactOperation->Execute();

    }

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

// CContactStore::LockContactL

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

//

void CContactStore::LockContactL

        (const CContact& aContact, MVPbkContactObserver& aObserver)

    {

    iAsyncContactOperation->PrepareL

        (MVPbkContactObserver::EContactLock, aContact, aObserver);

    iAsyncContactOperation->Execute();

    }

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

// CContactStore::ReadAndLockContactL

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

//

void CContactStore::ReadAndLockContactL

        (TContactItemId aContactId, MVPbkContactObserver& aObserver)

    {

    iAsyncContactOperation->PrepareL

        (MVPbkContactObserver::EContactReadAndLock, aContactId, aObserver);

    iAsyncContactOperation->Execute();

    }

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

// CContactStore::DeleteContactL

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

//

void CContactStore::DeleteContactL

        (TContactItemId aContactId, MVPbkContactObserver& aObserver)

    {

    iAsyncContactOperation->PrepareL

        (MVPbkContactObserver::EContactDelete, aContactId, aObserver);

    iAsyncContactOperation->Execute();

    }

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

// CContactStore::CommitContactL

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

//

void CContactStore::CommitContactL(

        const CContact& aContactItem,

        MVPbkContactObserver& aObserver)

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING

        ("CContactStore::CommitContactL(0x%x,0x%x)"),

        &aContactItem, &aObserver);

    iDiskSpaceCheck->DiskSpaceCheckL();

    // verify sync field content

    VPbkUtils::VerifySyncronizationFieldL(

        iStoreDomain.FsSession(),

        StoreProperties().SupportedFields(),

        const_cast<CContact&>(aContactItem));

    iAsyncContactOperation->PrepareL

        (MVPbkContactObserver::EContactCommit, aContactItem, aObserver);

    iAsyncContactOperation->Execute();

    }

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

// CContactStore::CreateLinkLC

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

//

MVPbkContactLink* CContactStore::CreateLinkLC(TContactItemId aContactId) const

    {

    MVPbkContactLink* ret = NULL;

    // if  aContactId is KGoldenTemplateId then it is probably new contact

    // which is not commited to contactdb, return null then

    if ( aContactId != KGoldenTemplateId &&

         aContactId != KNullContactId )

        {

        // Contact store constness casted away, no reason to be const

        ret = CContactLink::NewLC(const_cast<CContactStore&>(*this), aContactId);

        }

    return ret;

    }

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