/*

* Copyright (c) 2002 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: 

*     Represents a connection to the Phonebook contact database

*

*/

#ifndef __CPBKCONTACTENGINE_H__

#define __CPBKCONTACTENGINE_H__

//  INCLUDES

#include <e32base.h>        // CBase

#include <cntdef.h>         // TContactItemId

#include <cntdbobs.h>       // MContactDbObserver

#include <f32file.h>        // RFs

#include "PbkFields.hrh"    // TPbkFieldId

// FORWARD DECLARATIONS

class CContactDatabase;

class MIdleFindObserver;

class MPbkContactDbObserver;

class CContactGroup;

class CPbkFieldsInfo;

class CPbkContactItem;

class CPbkContactIter;

class CPbkContactChangeNotifier;

class CPbkIdleFinder;

class MPbkCompressUi;

class CPbkConstants;

class MPbkContactNameFormat;

class MPbkFieldDataArray;

class CContactViewBase;

class CContactItem;

class RSharedDataClient;

class TResourceReader;

class CPbkEngineExtension;

class CPbkSortOrderManager;

class CPbkSINDHandlerInterface;

// CLASS DECLARATION

/**

 * The main entrypoint to the Phonebook contact engine. The Phonebook

 * contact engine builds on top of the Symbian Contacts model and

 * implements platform specific functionality and policies that can be 

 * reused and followed by clients to implement functionality that is

 * better integrated to the platform functionality. Functionality like

 * contact field typing is implemented by this engine. 

 */

class   CPbkContactEngine :

        public CBase,

        private MContactDbObserver

    {

    public: // Constructors and destructor

        /**

         * Creates a new Phonebook engine object and connects to the default

         * contact database. If the default database does not exist it is

         * created.

         *

         * @param aFs   An open file server connection. If !=NULL aFs is used

         *              instead of a locally created RFs connection. aFs must

         *              remain connected for the lifetime of the returned

         *              object.

         * @return A new instance of this class.

         * @exception KErrCorrupt if the database is corrupted.

         */

		IMPORT_C static CPbkContactEngine* NewL(RFs* aFs=NULL);

        /**

         * @internal

         * TESTING ONLY

         * Creates a new engine object and connects it to a specified

         * database file. If the database file does not exist it is created.

         *

         * @param aFileName The database filename.

         * @param aReplace  If ETrue replaces exisiting file with an empty one.

         *                  PLEASE NOTE: all data in the existing file

         *                  will be lost!

         * @param aFs   An open file server connection. If !=NULL aFs is used

         *              instead of a locally created RFs connection. aFs must

         *              remain connected for the lifetime of the returned

         *              object.

         * @return A new instance of this class.

         * @exception KErrCorrupt if the database is corrupted.

         * @deprecated

         */

		IMPORT_C static CPbkContactEngine* NewL

            (const TDesC& aFileName, TBool aReplace=EFalse, RFs* aFs=NULL);

        /**

         * Replaces the default contact database and connects to it. See

         * Symbian Contacs model documentation for CContactDatabase::ReplaceL

         * for possible leave codes.

         * PLEASE NOTE: all data in the existing database will be lost!

         *

         * @param aFs   An open file server connection. If !=NULL aFs is used

         *              instead of a locally created RFs connection. aFs must

         *              remain connected for the lifetime of the returned

         *              object.

         * @return A new instance of this class.

         * @see CContactDatabase::ReplaceL

         */

        IMPORT_C static CPbkContactEngine* ReplaceL(RFs* aFs=NULL);

        /**

		* Destructor. Destroys this object and closes the contact database

		* connection. REComSession::FinalClose() is called. Notice that

		* FinalClose -call releases resource handles of already destroyed ECom

		* plugins also outside CPbkContactEngine. See REComSession

		* documentation.

		*/

		~CPbkContactEngine();

    public: // Accessors

        /**

         * Returns the global Phonebook engine instance, NULL if no instance

         * created yet.

         * Note1: Uses thread local storage (TLS), which is slow. Cache the

         * returned pointer if it is used more than one time!

         * Note2: Only the first engine instance created in calling thread can

         * be accessed with this function.

         * @return  Global Phonebook engine instance.

         */

        IMPORT_C static CPbkContactEngine* Static();

        /**

         * Returns the underlying CContactDatabase object. Use only if this class's API

         * is not enough for your purposes.

         *

         * @return The underlying Symbian Contacts model CContactDatabase instance.

         * @see CContactDatabase

         */

        IMPORT_C CContactDatabase& Database();

        /**

         * Returns the field type info array.

         * @return  All the Phonebook field types.

         * @see CPbkFieldsInfo

         */

        IMPORT_C const CPbkFieldsInfo& FieldsInfo();

        /**

         * Returns an open file server session.

         * @return  A handle to a file server session.

         */

        IMPORT_C RFs& FsSession() const;

    public:  // Creating contacts

        /**

         * Returns a new contact card with default fields.

         * @return  A new empty contact item object.

         */

        IMPORT_C CPbkContactItem* CreateEmptyContactL();

         /**

          * Adds a new contact to the contact database.

          *

          * @param aContact         The new contact item to add.

          * @param aImmediateNotify Send notification to observers immediately.

          *                         NOTE: send immediately will result in

          *                         observers (MPbkContactDbObserver) receiving

          *                         the event twice!

          * @return The id of the new contact item.

          * @see CContactDatabase::AddNewContactL

          */

        IMPORT_C TContactItemId AddNewContactL

            (CPbkContactItem& aContact, TBool aImmediateNotify=EFalse);

        /**

         * Duplicates a contact in the database.

         *

         * @param aId               Id of the contact to duplicate.

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @return  Contact id of the new duplicate.

         */

        IMPORT_C TContactItemId DuplicateContactL

            (TContactItemId aId, TBool aImmediateNotify=EFalse);

    public:  // Reading contacts

        /**

         * Reads a contact and returns a phonebook contact item.

         *

         * @param aContactId Contact item id to be read.

         * @param aFieldTypes   Array of types of fields to read in, all

         *                      fields are read if NULL (which is default).

         *                      NOTE: when using this parameter ReadContactL

         *                      may return more fields than expected; for example

         *                      if aFieldTypes contains any phonenumber the

         *                      method may return all phone number fields

         *                      of the contact.

         * @return A new Phonebook contact item.

         * @see CContactDatabase::ReadContactL

         */

        IMPORT_C CPbkContactItem* ReadContactL

            (TContactItemId aContactId, const CPbkFieldIdArray* aFieldTypes=NULL);

        /**

         * Same as ReadContactL, but leaves the returned contact item

         * on the cleanup stack.

         *

         * @param aContactId Contact item id to be read.

         * @param aFieldTypes   Array of types of fields to read in, all

         *                      fields are read if NULL (which is default).

         *                      NOTE: when using this parameter ReadContactL

         *                      may return more fields than expected; for example

         *                      if aFieldTypes contains any phonenumber the

         *                      method may return all phone number fields

         *                      of the contact.

         * @return A new Phonebook contact item.

         */

        IMPORT_C CPbkContactItem* ReadContactLC

            (TContactItemId aContactId, const CPbkFieldIdArray* aFieldTypes=NULL);

        /**

         * Same as ReadContactLC but reads only minimal information. See

         * Symbian Contacts Model documentation for definition of "minimal" in this

         * case.

         *

         * @param aContactId Contact item id to be read.

         * @return A new phonebook contact item. Leaves the item on the cleanup stack.

         * @see CContactDatabase::ReadMinimalContactL

         */

        IMPORT_C CPbkContactItem* ReadMinimalContactLC(TContactItemId aContactId);

        /**

         * Returns a Phonebook contact iterator.

         * @param aUseMinimalRead   If ETrue the iterator will use the Symbian

         * Contacts model CContactDatabase::ReadMinimalContactL, EFalse will read 

         * all the contact fields. Default behaviour is to read all fields.

         * @see CPbkContactIter::NewL.

         * @see CContactDatabase::ReadMinimalContactL

         */

        IMPORT_C CPbkContactIter* CreateContactIteratorLC

            (TBool aUseMinimalRead=EFalse);

    public:  // Modifying contacts

        /**

         * Opens a contact and returns a phonebook contact item.

         * @param aContactId Contact item id to be opened.

         * @return A Phonebook contact item that is marked as open in the database.

         * @see CContactDatabase::OpenContactL

         */

        IMPORT_C CPbkContactItem* OpenContactL(TContactItemId aContactId);

        /**

         * Same as OpenContactL, but leaves a lock record AND the opened

         * contact object on the cleanup stack.

         * Use CleanupStack::PopAndDestroy(2) to close the contact and destroy

         * the returned object. First pop pops the contact object and second

         * the lock object.

         * @param aContactId    Contact item id to open.

         * @return A Phonebook contact item that is marked as open in the database.

         * @see CContactDatabase::OpenContactLX

         */

        IMPORT_C CPbkContactItem* OpenContactLCX(TContactItemId aContactId);

        /**

         * Commit changes to a previously opened contact item into the contact

         * database.

         *

         * @param aContact          Contact item to be updated in the database.

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @see CContactDatabase::CommitContactL

         */

        IMPORT_C void CommitContactL

            (CPbkContactItem& aContact, TBool aImmediateNotify=EFalse);

        /**

         * Closes a previously opened contact item without saving changes.

         * @param aContactId Contact item to be closed.

         * @see CContactDatabase::CloseContactL

         */

    	IMPORT_C void CloseContactL(TContactItemId aContactId);

    public:  // Deleting contacts

        /**

         * Deletes a contact item from the database.

         * @param aContactId    Contact item to be deleted.

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @see CContactDatabase::DeleteContactL

         */

    	IMPORT_C void DeleteContactL

            (TContactItemId aContactId, TBool aImmediateNotify=EFalse);

        /**

         * Deletes multiple contact items from the database.

         * @param aContactIds    Contact items to be deleted.

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @see CContactDatabase::DeleteContactsL

         */

    	IMPORT_C void DeleteContactsL

            (const CContactIdArray& aContactIds, TBool aImmediateNotify=EFalse);

        /**

         * Deletes multiple contacts from the database in an active object

         * -driven asynchronous background process.

         *

         * @param aContactIds   Contacts to delete.

         */

        IMPORT_C void DeleteContactsOnBackgroundL

            (const CContactIdArray& aContactIds);

    public:  // Contact groups

        /**

         * Creates a new contact group.

         *

         * @param aGroupLabel   Group name.

         * @param aInTransaction    See Symbian Contacts Model documentation

         * for CContactDatabase::CreateContactGroupL documentation.

         * @see CContactDatabase::CreateContactGroupL

         */

        IMPORT_C CContactGroup* CreateContactGroupL

            (const TDesC& aGroupLabel,TBool aInTransaction=EFalse);

        /**

         * Adds a Contact to a group.

         *

         * @param aItemId   Contact to be added to group.

         * @param aGroupId  Group where the contact will be added to.

         * @see CContactDatabase::AddContactToGroupL

         */

    	IMPORT_C void AddContactToGroupL

            (TContactItemId aItemId, TContactItemId aGroupId);

        /**

         * Removes a contact from a group

         *

         * @param aItemId   Contact to be removed from group.

         * @param aGroupId  Group where the contact will be removed from.

         * @see CContactDatabase::RemoveContactFromGroupL

         */

    	IMPORT_C void RemoveContactFromGroupL

            (TContactItemId aItemId, TContactItemId aGroupId);

        /**

         * Reads a Contact group.

         *

         * @param aId Group id.

         * @return Contact group object.

         * @see CContactDatabase::ReadContactL

         */

        IMPORT_C CContactGroup* ReadContactGroupL(TContactItemId aId);

        /**

         * Opens a Contact group for modification.

         *

         * @param aId Groups id

         * @return Contact group object.

         * @see CContactDatabase::OpenContactL

         */

        IMPORT_C CContactGroup* OpenContactGroupL(TContactItemId aId);

        /**

         * Opens a Contact group for modification. Pushes the returned

         * contact group object and a lock item on the cleanup stack.

         *

         * @param aId Groups id

         * @return Contact group object.

         * @see CContactDatabase::OpenContactLX

         */

        IMPORT_C CContactGroup* OpenContactGroupLCX(TContactItemId aId);

        /**

         * Commits changes to a contact group to the database.

         *

         * @param aId Groups id

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @see CContactDatabase::CommitContactL

         */

        IMPORT_C void CommitContactGroupL(CContactGroup& aGroup, TBool aImmediateNotify=EFalse);

        /**

         * Deletes a contact group from the database.

         * @param aContactId    Contact group to be deleted.

         * @param aImmediateNotify  Send notification to observers immediately.

         *                          NOTE: send immediately will result in

         *                          observers (MPbkContactDbObserver) receiving

         *                          the event twice!

         * @see CContactDatabase::DeleteContactL

         */

        IMPORT_C void DeleteContactGroupL

            (TContactItemId aContactId, TBool aImmediateNotify=EFalse);

    public:  // Speed dials

        /**

         * Sets a speed dial to a contact field.

         *

         * @param aItem         Contact item to add speed dial to.

         * @param aFieldIndex   Field index to add Speed dial to.

         * @param aSpeedDialPosition    Speed dial position number to set to

         *                              the field.

         * @see CContactDatabase::SetFieldAsSpeedDialL

         */

        IMPORT_C void SetFieldAsSpeedDialL

            (CPbkContactItem& aItem, TInt aFieldIndex, TInt aSpeedDialPosition);

        /**

         * Returns a speed dial contact.

         *

         * @param   aSpeedDialPosition  Speed dial position number.

         * @param   aPhoneNumber        Phone number

         * @see CContactDatabase::GetSpeedDialFieldL.

         */

      	IMPORT_C TContactItemId GetSpeedDialFieldL

            (TInt aSpeedDialPosition, TDes& aPhoneNumber) const;

        /**

         * Removes a speed dial from a contact.

         *

         * @param   aContactId  Contact item to remove the speed dial from.

         * @param   aSpeedDialPosition  Speed dial position number to remove.

         * @see CContactDatabase::RemoveSpeedDialFieldL.

         */

    	IMPORT_C void RemoveSpeedDialFieldL

            (TContactItemId aContactId, TInt aSpeedDialPosition);

        /**

         * Returns ETrue if this field has been assigned a speed dial position.

         *

         * @param aItem contact Item to check for speed dial.

         * @param aFieldIndex   Index of the field to check. This is an index

         *                      into aItem.CardFields().

         * @return  ETrue if Speed dial exitst, EFalse if not.

         */

        IMPORT_C TBool IsSpeedDialAssigned

            (const CPbkContactItem& aItem, TInt aFieldIndex) const;

    public:  // Contact views

        /**

         * Returns a contact view object containing all the contacts in the

         * database.

         *

         * @return  Contact view containing all the contacts in the database.

         * @see CContactViewBase

         */

        IMPORT_C CContactViewBase& AllContactsView();

        /**

         * Returns a contact view object containing all the groups in the

         * database.

         *

         * @return  Contact view containing all the groups in the database.

         * @see CContactViewBase

         */

        IMPORT_C CContactViewBase& AllGroupsViewL();

        /**

         * Returns a contact view object containing all the contacts in the

         * database that match a filter.

         *

         * @param aFilter   Use CContactDatabase::TContactViewFilter.

         * @see CContactViewBase

         */

        IMPORT_C CContactViewBase& FilteredContactsViewL(TInt aFilter);

    public:  // Events

        /**

         * Creates and returns a new CPbkContactChangeNotifier for the

         * default contact database. The returned object attaches aObserver

         * to this engine instance as long as the object exists.

         *

         * @param aObserver Observer to attach to this object.

         * @return  New CPbkContactChangeNotifier object. Caller is responsible

         *          of the object.

         * @see CPbkContactChangeNotifier

         * @see MPbkContactDbObserver

         */

        IMPORT_C CPbkContactChangeNotifier* CreateContactChangeNotifierL

            (MPbkContactDbObserver* aObserver);

    public:  // Contact name formatting

        /**

         * Gets a title text for a contact or localised text for unnamed

         * contact if contact contains no title.

         *

         * @param   aItem   Contact item for which to make the title.

         * @return  A buffer containing the title or unnamed text if no title

         *          can be generated. Caller is responsible of deleting the

         *          returned buffer.

         */

        IMPORT_C HBufC* GetContactTitleL(const CPbkContactItem& aItem) const;

        /**

         * Similar to GetContactTitleL but returns NULL if contact contains no

         * title. Uses the MPbkFieldDataArray interface to access the field 

         * content.

         * @param aContactData  The contact field data array.

         * @return  Contact title, NULL if field array did not contain any fields

         * used to for constructing contact titles.

         * @see CPbkContactEngine::GetContactTitleL

         */

        IMPORT_C HBufC* GetContactTitleOrNullL

            (const MPbkFieldDataArray& aContactData);

        /**

         * Returns ETrue if field is one of the fields used in building the

         * contact title.

         *

         * @param aFieldId  The id of the field.

         * @return  ETrue if aFieldId is type of a field used to build contact

         *          titles.

         * @see GetContactTitleL

         * @see GetContactTitleOrNullL

         */

        IMPORT_C TBool IsTitleField(TPbkFieldId aFieldId) const;

        /**

         * @internal

         * Returns the contact name formatter.

         *

         * @see MPbkContactNameFormat

         * @deprecated

         */

        IMPORT_C MPbkContactNameFormat& ContactNameFormat() const;

        /**

         * Returns the localised title text to use for unnamed contacts.

         * @return  Localised title text to use for unnamed contacts.

         */

        IMPORT_C const TDesC& UnnamedTitle() const;

    public: // Searching

        /**

         * Call-through for new Phone number matching function in 6.2 version

         * of class CContactDatabase. If you don't need any other functionality

         * from CPbkContactEngine than this consider using the CContactDatabase

         * API directly. See Symbian Contacts Model documentation for 

         * CContactDatabase::MatchPhoneNumberL use.

         *

         * @see CContactDatabase::MatchPhoneNumberL(const TDesC&,const TInt)

         */

        IMPORT_C CContactIdArray* MatchPhoneNumberL

            (const TDesC& aNumber, const TInt aMatchLengthFromRight);

        /**

         * Searches all contacts in the database for aText.

         *

         * @param aText         Text to search.

         * @param aFieldTypes   Phonebook fields types to <i>at least</i>

         *                      include in the search. If NULL searches all

         *                      fields.<br>

         *                      <b>PLEASE NOTE:</b> The find matches in most

         *                      cases also other fields than those specified

         *                      in aFieldTypes. Always loop through the

         *                      returned contacts to check match in the

         *                      required fields.

         * @return Array of matching contact IDs.

         * @see CContactDatabase::FindLC.

         */

        IMPORT_C CContactIdArray* FindLC

            (const TDesC& aText, const CPbkFieldIdArray* aFieldTypes=NULL);

        /**

         * Searches all contacts in the database for aText asynchronously.

         *

         * @param aText         Text to search.

         * @param aFieldTypes   Phonebook fields types to <i>at least</i>

         *                      include in the search. If NULL searches all

         *                      fields.<br>

         *                      <b>PLEASE NOTE:</b> The find matches in most

         *                      cases also other fields than those specified

         *                      in aFieldTypes. Always loop through the

         *                      returned contacts to check match in the

         *                      required fields.

         * @param  aObserver    Observer for this operation.

         * @return  CPbkIdleFinder object which is used to access the find

         *          results when complete. Deleting this object will cancel

         *          this asyncronous find operation.

         * @see CContactDatabase::FindAsyncL.

         * @see CPbkIdleFinder

         */

	    IMPORT_C CPbkIdleFinder* FindAsyncL(

            const TDesC& aText,

            const CPbkFieldIdArray* aFieldTypes=NULL,

            MIdleFindObserver *aObserver=NULL);

    public:  // Phonebook internal API

        /**

         * @internal

         * Sets the compression UI for this engine.

         * To be called by Phonebook only!

         *

         * @see MPbkCompressUi

         * @see CheckCompress

         * @see CancelCompress

         * @deprecated

         */

        IMPORT_C void SetCompressUi(MPbkCompressUi* aCompressiUi);

        /**

         * @internal

         * Checks if the contact database needs a compression.

         * To be called by Phonebook only!

         *

         * @see SetCompressUi

         * @see CompressL

         * @see CancelCompress

         * @deprecated

         */

        IMPORT_C TBool CheckCompress();

        /**

         * @internal

         * Compresses the database if necessary. To be called by Phonebook only.

         *

         * @see SetCompressUi

         * @see CancelCompress

         * @deprecated

         */

        IMPORT_C void CompressL();

        /**

         * @internal

         * Call to cancel any ongoing database compression started with

         * CheckCompressL(). Calls PbkCompressCanceled() for any registered

         * compression UI. To be called by Phonebook only.

         *

         * @see SetCompressUi

         * @see CheckCompress

         * @deprecated

         */

        IMPORT_C void CancelCompress();

        /**

         * @internal

         * Checks current file system space and amount of wasted space in

         * Phonebook's database. Compresses the database synchronously if

         * Phonebook's database can be made smaller by compression. If file

         * system space is still under critical level after compression,

         * leaves with KErrDiskFull.

         *

         * @exception KErrDiskFull if file system is out of space.

         * @deprecated

         */

        IMPORT_C void CheckFileSystemSpaceAndCompressL();

		/**

		 * @internal

		 * Phonebook name ordering information.

         * @deprecated

		 */

		enum TPbkNameOrder

			{

			EPbkNameOrderLastNameFirstName = 0, /// Last name then first name order

			EPbkNameOrderFirstNameLastName, /// First name then last name order

			EPbkNameOrderNotDefined /// undefined name order

			};

		/**

		 * @internal

		 * Sets name display order.

		 * @param aNameOrder The ordering to use

         * @deprecated

		 */

		IMPORT_C void SetNameDisplayOrderL(TPbkNameOrder aNameOrder);

		/**

		 * @internal

		 * Gets name display order.

		 * @return The name ordering in use

         * @deprecated

		 */

		IMPORT_C TPbkNameOrder NameDisplayOrderL();

		/**

		 * @internal

		 * Returns the phonebook constants object.

         * @return Phonebook constants manager

         * @deprecated

		 */

		IMPORT_C CPbkConstants* Constants();

        /**

         * @internal

         * Returns the sort order manager of the engine.

         */

        const CPbkSortOrderManager& SortOrderManager() const;

		/**

		 * @internal

		 * Sets whether a separator character is shown between

		 * last and first names.

		 * @param aSeparator This parameter should contain the character to be

		 *	      used as separator. If value is 0 then separator will not be

		 * 	      used between names.

		 */

		IMPORT_C void SetNameSeparatorL(TChar aSeparator);

        /**

		 * @internal

		 * Return info on whether separator character is used between last

		 * and first names.

		 * @return The separator character. Empty (value 0) if there is no

         *         separator.

		 */

		IMPORT_C TChar NameSeparator() const;

    private:  // from MContactDbObserver

        void HandleDatabaseEventL(TContactDbObserverEvent aEvent);

    private:  // Interface for CPbkContactChangeNotifier

        friend class CPbkContactChangeNotifier;

        void AddObserverL(MPbkContactDbObserver* aObserver);

        void RemoveObserver(MPbkContactDbObserver* aObserver);

        void SendEventToAllObservers(const TContactDbObserverEvent& aEvent);

    private:  // Implementation

		CPbkContactEngine();

		void ConstructL(const TDesC* aFileName, TBool aReplace, RFs* aFs);

        void ConnectFsL(RFs* aRfs);

        void ReadResourcesL(TBool& aSettingsVisibility);

        void CreateDbConnectionL(const TDesC* aFileName, 

                                 TBool aReplace, 

                                 TInt& aDbOpenError,

                                 TBool aSettingsVisible);

        void SendImmidiateEventToAllObservers(

            TContactDbObserverEventType aEventType,

            TContactItemId aContactId, TBool aSendEvent);

        void doDeleteContactL(TContactItemId aContactId);

        class CContactDbConnection;

        friend class CContactDbConnection;

		friend class CPbkSharedDataObserver;

    private:  // Data

        /// Ref: file server connection

        RFs iFs;

        /// Own: file server connection

        RFs iOwnFs;

        /// Own: Contact database connection object.

		CContactDbConnection* iDbConnection;

        /// Own: Observer array

        CArrayPtr<MPbkContactDbObserver>* iObservers;

        /// Own: fields info array.

        CPbkFieldsInfo* iPbkFieldsInfo;

        /// Own: Phonebook constants

        CPbkConstants* iPbkConstants;

        /// Own: shared data client

        RSharedDataClient* iSharedDataClient;

        /// Own: maximum free space required to delete a contact from the DB

        TInt iFreeSpaceRequiredToDelete;

        /// Own: Engine extension interface

        CPbkEngineExtension* iExtension;

        /// Is separator used between first- and last-names of contacts

        TBool iUseSeparator;

        /// The separator to be used between first- and last-names of contacts

        TChar iSeparator;

        /// CPbkSINDHandler instance identifier key.

        TUid iDtorIDKey;

        /// Own: SIND Handler

        CPbkSINDHandlerInterface* iSINDHandler;

    };

#endif   // __CPBKCONTACTENGINE_H__

// End of File