// Copyright (c) 1997-2009 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:

//

#ifndef __CNTDB_H__

#define __CNTDB_H__

// System includes

#include <e32base.h>

#include <cntdef.h>

#include <cntdbobs.h>

#include <cntsync.h>

#include <s32file.h>

#include <badesca.h>

#include <versit.h>

#include <collate.h>

#include <ecom/ecom.h>

// Classes referenced

//

class CContactViewDef;

class CFoundMatches;

class CContactTextDef;

class CContactItem;

class CContactItemViewDef;

class CContactItemFieldSet;

class CContactItemFieldDef;

class CContactActiveCompress;

class CContactActiveRecover;

class CContactDatabase;

class CContactTables;

class CCntFilter;

class CContentType;

class CContactItemField;

class CIdleFinder;

class CContactClientSession;

class CPrivConverter;

class RCntModel;

class CProxyFactory;

class CCntTemplateCache;

class CSortArray;

class CCntIdleSorter;

class MLplPersistenceLayerFactory;

class CContactOpenOperation;

class CDataBaseChangeObserver;

class CContactConverter;

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

class CContactSynchroniser;

#endif

// Constants

/** 

Maximum string length used to separate the fields in the text definition.

@see TContactTextDefItem

@publishedAll

@released

*/

const TInt KMaxContactTextSeperator=4;

/** 

Constant used during sorting and searching of contacts.

@publishedAll

@released

*/

const TInt KTextFieldMinimalLength=64;

/** 

Maximum number of fields that can be set as filterable fields by licensees.

@publishedAll

@released

*/

const TInt KMaxCustomFilterableFields=4;

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

/** @internalComponent */

const TInt KMajorVersion=1;

/** @internalComponent */

const TInt KMinorVersion=0;

/** @internalComponent */

const TInt KBuildNumber=40;

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

//

// Classes used for compact

//

class MContactStorageObserver

/**

Mixin used to observe low disk events

@publishedAll

@released

*/

	{

public:

	virtual void HandleDiskSpaceEvent(TInt aDrive) = 0;

	};

class MContactUiCompactObserver

/** Mixin used to observe contact database compaction status

@publishedAll

@released

*/

	{

public:

	virtual void Step(TInt aStep)=0;

	virtual void HandleError(TInt aError)=0;

	};

class MContactUiActive

/**  Mixin used to register the observer.

@publishedAll

@released

*/

	{

public:

	virtual void Cancel()=0;

	virtual void SetObserver(MContactUiCompactObserver *aObserver)=0;

	virtual TInt StepsTogo() const=0;

	virtual TInt Step()=0;

	virtual TInt Error() const=0;

private:

	IMPORT_C virtual void MContactUiActive_Reserved1();

	};

class CContactActiveBase : public CBase, public MContactUiActive

/**

@publishedAll

@released

*/

	{

public:

	~CContactActiveBase();

	void SetObserver(MContactUiCompactObserver *aObserver);

	void Cancel();

	TInt StepsTogo() const;

	TInt Step();

	TInt Error() const;

	void SetContactDatabase(CContactDatabase* aContactDatabase);

	void SetFileManagerL(RCntModel& aCntSvr);

#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ 	

protected:

	MContactUiCompactObserver *iObserver;

	RCntModel* iCntSvr; 

	CIdle *iIdle;

	TInt iStep;

	TInt iError;

	CContactDatabase* iContactDatabase;

#endif	

	};

class CContactActiveCompress : public CContactActiveBase

/**

@publishedAll

@released

*/

	{

public:

#if !( defined __SYMBIAN_CNTMODEL_HIDE_DBMS__ && defined __SYMBIAN_CNTMODEL_USE_SQLITE__ )

    void ConstructL(RDbNamedDatabase /* &aDataBase */) {};

#endif	

	};

class CContactActiveRecover : public CContactActiveBase

/**

@publishedAll

@released

*/

	{

public:

#if !( defined __SYMBIAN_CNTMODEL_HIDE_DBMS__ && defined __SYMBIAN_CNTMODEL_USE_SQLITE__ )

    void ConstructL(RDbNamedDatabase /* &aDataBase */) {};

#endif	

	};

class TContactTextDefItem

/** An item in a text definition.

A TContactTextDefItem has a field type and an optional separator string

with a maximum length of 4 characters.

@see CContactTextDef

@publishedAll

@released

*/

	{

public:

	IMPORT_C TContactTextDefItem();

	IMPORT_C TContactTextDefItem(TFieldType aFieldType);

	IMPORT_C TContactTextDefItem(TFieldType aFieldType, const TDesC &aSeperator);

public:

	/** The field type. */

	TFieldType iFieldType;

	/** The string used to separate the fields in the text definition. */

	TBuf<KMaxContactTextSeperator> iSeperator;

	};

class CContactTextDef : public CArrayFixFlat<TContactTextDefItem>

/** Defines a way of grouping fields to form a string which represents

a contact item.

A text definition is implemented as an array of text definition items

(TContactTextDefItems).

For example, CContactDatabase::ReadContactTextDefL() uses a text definition to

build up a string from a contact item. When creating the string, it searches

the item for fields whose type matches one of the fields specified in the text

definition. The contents of the first matching field of each type found in the

item are read into the string. These strings may be separated using a field

separator, which is also specified in the text definition. A separator is not

appended to the last field used to make up the string. It is only inserted when

there is a following non-empty field.

Additionally, the text definition may also contain a fallback field

type. This is used when none of the fields specified in the text

definition contain any text. If the item's fallback field contains no text

either, or if the fallback field type's value is KUidContactFieldNone, the

text is read from the first non-empty field in the item.

A contact database can have a default text definition which is set using CContactDatabase::SetTextDefinitionL().

This may be overridden using the variants of CContactDatabase::ReadContactTextDefL()

which take a CContactTextDef* argument.

CContactTextDef is derived from CArrayFixFlat<TContactTextDefItem>, so all

relevant functions can be used, e.g. to add and remove elements.

@publishedAll

@released

*/

	{

	friend class CContactDatabase;

	friend class CContactTables;

public:

	CContactTextDef();

	IMPORT_C static CContactTextDef* NewL();

	IMPORT_C static CContactTextDef* NewLC();

	static CContactTextDef* NewLC(RReadStream& aStream);

	IMPORT_C void SetFallbackField(TFieldType iFieldType);

	IMPORT_C TFieldType FallbackField() const;

	IMPORT_C TBool ExactMatchOnly();

	IMPORT_C void SetExactMatchOnly(TBool aExactMatchOnly);

	void ExternalizeL(RWriteStream& aStream) const;

	void InternalizeL(RReadStream& aStream);	

private:

	TFieldType iFallbackFieldType;

	TBool iExactMatchOnly;//Default to EFalse cause ReadInTextDef to only match the chosen fields and not attempt a matchall

	};

class CContactItemViewDef : public CBase

/** A view definition for a contact item.

When reading or opening a contact item using the CContactDatabase class,

a view definition may be specified to indicate which field data should be

retrieved. See for instance CContactDatabase::ReadContactL().

A view definition for a contact item contains an array of field types, a use

(CContactItemViewDef::TUse) and a mode (CContactItemViewDef::TMode). The use

indicates whether the field types contained in the view definition should

be included in or excluded from the view. The mode indicates whether fields

with the hidden attribute should be included or excluded.

@publishedAll

@released

*/

	{

public:

	/** Include or exclude specified fields. */

	enum TUse

			{

			/** Include specified fields in the view. */

			EIncludeFields,

			/** Exclude specified fields from the view. */

			EMaskFields

			};

	/** Include or exclude hidden fields.*/

	enum TMode

			{

			/** Include hidden fields in the view. */

			EIncludeHiddenFields,

			/** Exclude hidden fields from the view. */

			EMaskHiddenFields

			};

public:

	IMPORT_C static CContactItemViewDef* NewL(TUse aUse, TMode aMode);

	IMPORT_C static CContactItemViewDef* NewLC(TUse aUse, TMode aMode);

	static CContactItemViewDef* NewLC(RReadStream& aStream);

    inline TUid operator[](TInt aIndex) const;

    IMPORT_C TInt Find(const CContentType &aContentType) const;

    IMPORT_C TInt Find(TFieldType aFieldType) const;

    inline TInt Count() const;

    inline void Reset();

	IMPORT_C void AddL(TFieldType aFieldType);

	IMPORT_C void Remove(TFieldType aFieldType);

	IMPORT_C void Remove(TInt aIndex);

	inline TUse Use() const;

	inline void SetUse(TUse aUse);

	inline TMode Mode() const;

	inline void SetMode(TMode aMode);

	IMPORT_C TBool Contains(const CContactItem& aItem);

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C TBool MatchesAll() const;

private:

	CContactItemViewDef(TUse aUse,TMode aMode);

private:

    CArrayFixFlat<TUid> iFieldTypes;

	TUse iUse;

	TMode iMode;

	};

class CContactViewDef : public CBase

/** Specifies a subset of fields to be loaded when reading a contact item.

A default view definition is owned by the contact database.

It is set using CContactDatabase::SetViewDefinitionL() and is used in calls

to CContactDatabase::ReadContactL(), ReadContactLC() and ReadContactAndAgentL()

when no view definition is specified.

The view definition owns the item view definition (see the CContactItemViewDef

class), which stores the view definition's field types, use and mode.

The following functions declared in class CContactViewDef have not been

implemented:- Groups(), AddL().

@publishedAll

@released

*/

	{

public:

	IMPORT_C static CContactViewDef* NewL();

	IMPORT_C static CContactViewDef* NewLC();

	IMPORT_C static CContactViewDef* NewL(CContactItemViewDef* aItemDef);

	IMPORT_C static CContactViewDef* NewLC(CContactItemViewDef* aItemDef);

	static CContactViewDef* NewLC(RReadStream& aStream);

	IMPORT_C ~CContactViewDef();

	IMPORT_C void InternalizeL(RReadStream& aStream);

	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

	IMPORT_C CContactItemViewDef& ItemDef() const;

	/** This function is not implemented    */

	IMPORT_C CContactIdArray& Groups() const;

	/** This function is not implemented. 

	@param aFieldType The field type to append to the array of field types. */

	inline void AddL(TFieldType aFieldType);

private:

	CContactViewDef();

	void ConstructL(CContactItemViewDef* aItemDef);

private:

	CContactItemViewDef* iItemDef;

//	CContactIdArray* iGroupIds; // unused for now

	};

class TContactIter

/** Iterates through the sorted contact items in a contact database.

A value of KNullContactId is returned by the iterator if a requested item cannot

be found.

@publishedAll

@released

*/

	{

public:

	IMPORT_C TContactIter(CContactDatabase &aDatabase);

	IMPORT_C TContactItemId FirstL();

	IMPORT_C TContactItemId NextL();

	IMPORT_C TContactItemId PreviousL();

	IMPORT_C TContactItemId LastL();

	IMPORT_C void GotoL(TContactItemId aContactId);

	IMPORT_C void Reset();

private:

	void GotoIndexL(TInt aPos);

private:

	CContactDatabase &iDatabase;

	TContactItemId iCursorId;

	};

class MIdleFindObserver

/** The interface for an asynchronous find observer.

An object which implements this interface is passed to the asynchronous find

functions defined in class CContactDatabase, (FindAsyncL() and FindInTextDefAsyncL()).

The observer would typically notify the user of the progress of the operation.

@publishedAll

@released

*/

	{

public:

	/** Asynchronous find observer callback.

	If an observer is supplied to CContactDatabase::FindAsyncL()

	or FindInTextDefAsyncL(), this callback function is called by CIdle::RunL()

	when nothing of a higher priority can be scheduled. It is called for every

	16 items searched to give the application a chance to update its search status.

	An implementation might test for and handle errors and retrieve information

	about the progress of the search. This information may be retrieved using

	functions provided by the CIdleFinder class. */

	virtual void IdleFindCallback()=0;

	};

struct SFindInTextDefWordParser

/** Search string parser struct.

An object of this type is used in the callback parser function passed to

CContactDatabase::FindInTextDefLC(). The parser function must walk

through and parse iSearchString, adding any words found to iWordArray.

@publishedAll

@released

*/

	{

public:

	inline SFindInTextDefWordParser(const TDesC *aSearchString, CDesCArray *aWordArray) : iSearchString(aSearchString), iWordArray(aWordArray)

	/** Initialises the search string and the word array.

	@param aSearchString Pointer to the input string to be parsed.

	@param aWordArray Pointer to the array to which words parsed from the input

	string should be added. */

		{};

public:

	/** Pointer to the input string to be parsed. */

	const TDesC *iSearchString;

	/** Pointer to the array to which words parsed from the input string should be

	added. */

	CDesCArray *iWordArray;

	};

class CIdleFinder : public CIdle

/** Provides information about the progress of an asynchronous contact database search,

and can be used to get the results of the search.

An instance of this class is returned by calls to CContactDatabase::FindAsyncL()

and CContactDatabase::FindInTextDefAsyncL().

@publishedAll

@released

*/

	{

public:

	~CIdleFinder();

	IMPORT_C TBool IsComplete() const;

	IMPORT_C CContactIdArray *TakeContactIds();

	IMPORT_C TInt Error() const;

	TInt RunError(TInt aError);

private:

	friend class CContactDatabase;

	static CIdleFinder *NewL(CContactDatabase &aContactDatabase, const TDesC& aText, const CContactItemFieldDef *aFieldDef, MIdleFindObserver *aObserver);

	static CIdleFinder *NewL(CContactDatabase &aContactDatabase, const MDesCArray* aFindWords,const CContactTextDef* aTextDef, MIdleFindObserver *aObserver, const TCallBack &aWordParserCallback);

	void DoCancel();

	void Start();

	static TInt CallbackL(TAny *aSelf);

	void ConstructL(const TDesC *aText, const MDesCArray* aFindWords, const TCallBack *aWordParserCallback);

	TBool ScanForMatchL(const TDesC &aFieldText,const TDesC &aFindText, CFoundMatches *aFoundMatches) const;

	TBool CheckFindL(TContactItemId aContactId) const;

	TBool CheckFindL() const;

	CIdleFinder(CContactDatabase &aContactDatabase, const CContactItemFieldDef *aFieldDef, const CContactTextDef* aTextDef, MIdleFindObserver *aObserver);

	TBool doFindL();

	enum TAsyncFindState

		{

		EFindInBlobFinished				=0x00000001,

		EFindInIdentityFinished			=0x00000002,

		EFindInEmailFinished			=0x00000004,

		EFindInTextDefFinished			=0x00000008

		};

private:

	CContactDatabase *iContactDatabase;

	CContactIdArray *iIdsFound;

	TBool iOwnsIds;

	CDesCArray*		iFindWords;

	TInt iReserved1;

	TInt iReserved2;

	TInt iReserved3;

	const CContactItemFieldDef* iFieldDef;

	const CContactTextDef* iTextDef;

	MIdleFindObserver *iObserver;

	TInt iError;

	TCallBack iWordParserCallback;

	TInt iReserved4;

	TInt iReserved5;

	TInt iReserved6;

	TInt iReserved7; //was 	TDbColNo

	TInt iReserved8; //was 	RDbView

	TInt iReserved9; //was 	RDbView

	TInt iReserved10; //was CIdentityTableColSet*

	};

class MContactDbPrivObserver

/** Provides notification of database changes to clients. 

* Provides information about database change event details and the type of changed event.

@publishedAll

@released

*/

	{

public:

#if !( defined __SYMBIAN_CNTMODEL_HIDE_DBMS__ && defined __SYMBIAN_CNTMODEL_USE_SQLITE__ )

	virtual void HandleDatabaseEventL(RDbNotifier::TEvent)=0;

#endif	

	virtual void HandleDatabaseEventL(const TContactDbObserverEvent &aEvent)=0;

	};