/*

* 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