/*

* 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"

// 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

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

// CContactStoreOpenOperation

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

//

class CContactStoreOpenOperation : public CActive

{

public: // construction & destruction

    /**

     * Open native contact database operation. Started automatically.

     *

     * @param aStore Store that will receive events when operation is complete 

     * @param aReplace replace contact database (instead of open)

     */

    CContactStoreOpenOperation( CContactStore& aStore, TBool aReplace );

    ~CContactStoreOpenOperation();

private: // From CActive

    void DoCancel();

    void RunL();

    TInt RunError( TInt aError );

private: // data types

    /// Operation states

    enum TStates

        {

        // Operation: Replace default store

        // Next states: [EStateDone]

        EStateReplaceStore,

        // Operation: Open default store

        // Next states: [EStateStoreOpened]

        EStateOpenStore,

        // Result: State when store has been opened (success or failure) 

        // Next states: [EStateStoreOpenedAfterError, EStateDone]

        EStateStoreOpened,

        // Result: State after second attempt to open store (first have failed).

        // Next states: [EStateDone]

        EStateStoreOpenedAfterError,

        // Result: DB has been opened successfully. Report it to store. 

        // Next states: -

        EStateDone,

        };

private: // implementation

    /**

     * Move to next state asynchronously

     */

    void IssueRequest( TStates aNextState, TInt aError = KErrNone );

    /**

     * Handle state EStateStoreOpened

     */

    void HandleStoreOpenedL( TInt aError );

private: // data

    /// Active state

    TStates iState;

    /// Ref: Contact store

    CContactStore& iStore;

    /// Own: Native contact database

    CContactDatabase* iDb;

    /// Own: Native contact database open operation

    CContactOpenOperation* iOperation;

};

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

// CContactStoreOpenOperation::~CContactStoreOpenOperation

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

//

CContactStoreOpenOperation::~CContactStoreOpenOperation()

    {

    Cancel();

    delete iDb;

    delete iOperation;

    }

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

// CContactStoreOpenOperation::DoCancel

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

//

void CContactStoreOpenOperation::DoCancel()

    {

    delete iOperation;

    iOperation = NULL;

    }

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

// CContactStoreOpenOperation::RunL

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

//

void CContactStoreOpenOperation::RunL()

    {

    switch( iState )

        {

        case EStateReplaceStore:

            {

            iDb = CContactDatabase::ReplaceL( 

                iStore.StoreProperties().Name().UriDes() );

            IssueRequest( EStateDone );

            break;

            }

        case EStateOpenStore:

            {

            iOperation = CContactDatabase::Open( 

                iStore.StoreProperties().Name().UriDes(), iStatus );

            SetActive();

            iState = EStateStoreOpened;

            break;

            }

        case EStateStoreOpened:

            {

            HandleStoreOpenedL( iStatus.Int() );

            break;

            }

        case EStateStoreOpenedAfterError:

            {

            User::LeaveIfError( iStatus.Int() ); // report errors immediately

            iDb = iOperation->TakeDatabase();

            IssueRequest( EStateDone );

            break;

            }

        case EStateDone:

            {

            CContactDatabase* db = iDb;

            iDb = NULL; // give ownership

            CContactStore& store = iStore;

            TRAPD( err, store.StoreOpenedL( db ) );

            // NOTE! Don't touch members after this call.

            // This instance could be deleted

            if( err )

                {

                store.StoreOpenFailed( err );

                }

            break;

            }

        default:

            {

            // unknown state

            __ASSERT_DEBUG( EFalse,

                ContactStorePanic( EPreCond_OpenOperationState ) );

            iStore.StoreOpenFailed( KErrUnknown );

            }

        }

    }

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

// CContactStoreOpenOperation::RunError

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

//

TInt CContactStoreOpenOperation::RunError( TInt aError )

    {

    iStore.StoreOpenFailed( aError );

    return KErrNone;

    }

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

// CContactStoreOpenOperation::CContactStoreOpenOperation

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

//

CContactStoreOpenOperation::CContactStoreOpenOperation( 

    CContactStore& aStore, TBool aReplace ) : 

    CActive( EPriorityLow ),

    iStore( aStore )

    {

    CActiveScheduler::Add( this );

    IssueRequest( aReplace ? EStateReplaceStore : EStateOpenStore ); // start working

    }

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

// CContactStoreOpenOperation::IssueRequest

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

//

void CContactStoreOpenOperation::IssueRequest( TStates aNextState, TInt aError )

    {

    if( !IsActive() )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, aError );

        SetActive();

        iState = aNextState; 

        }

    }

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

// CContactStoreOpenOperation::HandleStoreOpenedL

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

//

void CContactStoreOpenOperation::HandleStoreOpenedL( TInt aError )

    {

    if( aError == KErrNone )

        {

        // Store opened succesfully

        iDb = iOperation->TakeDatabase();

        IssueRequest( EStateDone );

        }

    else // some error happened

        {

        delete iOperation;

        iOperation = NULL;

        const TDesC& dbName = iStore.StoreProperties().Name().UriDes();

        TInt creating = EFalse;

        if( aError == KErrNotFound )

            {

            // Database not found --> Creating it

            creating = ETrue;

            TRAP( aError, iDb = CContactDatabase::CreateL( dbName ) );

            }

        if ( KErrDiskFull == aError )

            {

            // Try to release space for contact db opening

            if( iStore.RequestFreeDiskSpaceLC( KDiskSpaceForDbOpening ) )

                {

                aError = KErrNone;

                if( creating )

                    {

                    // Databse was not found --> Creating it