--- a/epoc32/include/cntviewbase.h Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/cntviewbase.h Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,908 @@
-cntviewbase.h
+// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#ifndef __CNTVIEWBASE_H__
+#define __CNTVIEWBASE_H__
+
+// System includes
+#include <e32std.h>
+#include <s32mem.h>
+
+#include <cntdb.h>
+
+// Classes referenced
+class CViewContactExtension;
+class CContactViewBase;
+class CContactRemoteViewNotifier;
+class CIdleContactSorter;
+class CContactViewFindConfigInterface;
+class CViewContactSortPlugin;
+class TSortPluginViewParams;
+
+/** View preferences for sorted contact views.
+
+This is used to specify the types of contact item that should be sorted and
+included in the view and the behaviour for items that cannot be sorted because
+they do not have content in any of the fields specified in the view's sort
+order.
+
+The default behaviour is to include contact cards only and to sort contact
+cards without content in any of the sort order fields using the first available
+field containing any text.
+
+The view preferences for all concrete contact view classes can be retrieved
+using their implementation of CContactViewBase::ContactViewPreferences().
+The view preferences are set during construction of a CContactLocalView.
+
+@publishedAll
+@released
+*/
+enum TContactViewPreferences
+ {
+ /** Only contact cards (of type KUidContactCard or KUidContactOwnCard) are included
+ in the view. This is the default. */
+ EContactsOnly =0x00000000,
+ /** Only contact groups (of type KUidContactGroup) are included in the view. */
+ EGroupsOnly =0x00000001,
+ /** Contact groups and contact cards (of type KUidContactGroup, KUidContactCard
+ or KUidContactOwnCard) are included in the view. */
+ EContactAndGroups =0x00000002,
+ /** Excludes contact items from the view which don't have content in any of the
+ fields specified in the sort order. */
+ EIgnoreUnSorted =0x00000004,
+ /** Includes contacts in the view which don't have content in any of the fields
+ specified in the sort order. These contacts are placed in an unsorted contact
+ list which is located before the sorted list. */
+ EUnSortedAtBeginning =0x00000008,
+ /** Includes contacts in the view which don't have content in any of the fields
+ specified in the sort order. These contacts are placed in an unsorted contact
+ list which is located after the sorted list. */
+ EUnSortedAtEnd =0x00000010,
+ /** Fields containing a single white space only are treated as empty, and therefore
+ unsortable. */
+ ESingleWhiteSpaceIsEmptyField =0x00000020,
+ /** Only ICC entries (of type KUidContactICCEntry) are included in the view. */
+ EICCEntriesOnly =0x00000040,
+ /** Only contact cards and ICC entries (of type KUidContactCard, KUidContactOwnCard
+ or KUidContactICCEntry) are included in the view. */
+ EICCEntriesAndContacts =0x00000080
+ };
+
+
+class TContactViewEvent
+/** Identifies a contact view event.
+
+Sent by contact views when notifying their observers of an event.
+
+@see MContactViewObserver::HandleContactViewEvent()
+@publishedAll
+@released
+*/
+ {
+public:
+ /** Identifies the event's type. */
+ enum TEventType
+ {
+ /** The observed view's state has changed from EReady to either ENotReady or EInitializing,
+ so is not available for use. */
+ EUnavailable,
+ /** The observed view's state has changed from ENotReady or EInitializing to EReady
+ so is available for use. */
+ EReady,
+ /** The observed view's sort order has changed, so observer views need to update
+ themselves. */
+ ESortOrderChanged,
+ /** An error occurred when sorting the observed view or when appending an observer
+ to its observer array.
+
+ The error code is provided in iInt. */
+ ESortError,
+ /** An error occurred in the contacts server.
+
+ The error code is provided in iInt. */
+ EServerError,
+ /** An error occurred when setting the range for a CContactSubView.
+
+ The error code is provided in iInt. */
+ EIndexingError,
+ /** An item has been added to the observed view.
+
+ The ID of the added item is provided in iContactId and the index into the
+ observed view of the added item is provided in iInt.
+ Exception from this are the first version of CContactFindView, CContactSubView and
+ CContactGroupView classes.
+ For these classes, iInt has KErrNone value */
+
+ EItemAdded,
+ /** An item has been removed from the observed view.
+
+ The ID of the removed item is provided in iContactId and the index into the
+ observed view of the item is provided in iInt.
+ Exception from this are the first version of CContactFindView and CContactSubView classes.
+ For these classes, iInt has KErrNone value */
+
+ EItemRemoved,
+ /** A change has occurred in a contact group, for instance a contact item has been
+ moved into or out of the group.
+
+ The ID of the group affected is provided in iContactId. */
+ EGroupChanged
+ };
+public:
+ inline TContactViewEvent();
+ inline TContactViewEvent(TEventType aEventType,TInt aInt = KErrUnknown,TContactItemId aContactId = KErrUnknown);
+public:
+ /** The type of event. */
+ TEventType iEventType;
+ /** The error code (where relevant) or the index of the contact item added to/removed
+ from the underlying view. */
+ TInt iInt;
+ /** The ID of the contact item that has been added or removed or the group ID, where
+ relevant. */
+ TContactItemId iContactId;//ContactId that has been added / removed if relevant.
+ };
+
+
+struct TContactIdWithMapping
+/** A struct used internally by filtered and group views to pair a contact item
+ID and its index into the underlying view.
+@publishedAll
+@released
+*/
+ {
+ /** The contact item's ID. */
+ TContactItemId iId;
+ /** The index of the item into the view's underlying view. */
+ TInt iMapping;
+ };
+
+
+class MContactViewObserver
+/** The interface for a contact view observer.
+
+Objects that need to observe a contact view should implement this interface.
+The view observer should be passed to the observed view's OpenL() or Open()
+function. This adds the observer to the view's observer array: a view can
+have more than one observer. The observers receive notifications when the
+observed view becomes ready for use and when changes occur in it.
+
+Many contact view classes implement this interface to observe an underlying
+view. They in turn send notification to any objects observing them.
+
+@see CContactViewBase::NotifyObservers()
+@see CContactViewBase::NotifyObserverAsync()
+@publishedAll
+@released
+*/
+ {
+public:
+ /** Handles an event in an observed contact view.
+
+ @param aView The contact view causing the notification.
+ @param aEvent The event. */
+ virtual void HandleContactViewEvent(const CContactViewBase& aView,const TContactViewEvent& aEvent)=0;
+ };
+
+
+class RContactViewSortOrder
+/** Specifies the sort order for a contact view.
+
+It is implemented as an array of TFieldType UIDs, which define the fields
+whose contents are used to sort on, and their order.
+
+The sort order for all concrete contact view classes can be retrieved using
+their implementation of CContactViewBase::SortOrderL(). The sort order is
+set during construction of local and remote views.
+@publishedAll
+@released
+*/
+ {
+public:
+ IMPORT_C RContactViewSortOrder();
+ IMPORT_C void Close();
+ IMPORT_C void CopyL(const RContactViewSortOrder& aSortOrder);
+ IMPORT_C void InternalizeL(RReadStream& aStream);
+ IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+ IMPORT_C TInt ExternalizedSize() const;
+ IMPORT_C TBool operator==(const RContactViewSortOrder& aSortOrder) const;
+ inline void AppendL(TFieldType aField);
+ inline TFieldType operator[](TInt aIndex) const;
+ inline TInt Count() const;
+private:
+ RArray<TFieldType> iFields;
+ TInt iSpare;
+ TInt32 iSpare2;
+ TInt32 iSpare3;
+ };
+
+
+/**
+Wrapper around RArray, to container TTextFieldMinimal buffers.
+
+Features: minimum size 1, easy resize of array, persistent last counted total.
+
+@internalComponent
+@released
+*/
+class RFieldBufferArray : public RArray<CContactDatabase::TTextFieldMinimal>
+ {
+public:
+ explicit RFieldBufferArray();
+
+ void ResizeL(TInt aNewSize);
+ void ZeroAll();
+ TInt NewTotal();
+ TInt LastTotal() const;
+
+private:
+ TInt iTotalLength;
+ };
+
+
+
+class CViewContact : public CBase
+/** The representation of a contact item used in contact views.
+
+It stores the contact item ID and other information. This includes a buffer
+holding the contents of all the item's fields, an array of indexes into the
+buffer indicating the start position of each field and a hint bit field (a
+combination of CContactDatabase::TContactViewFilter values) which is used
+in filtered views.
+
+The fields are defined by the view's sort order (RContactViewSortOrder).
+@publishedAll
+@released
+*/
+ {
+public:
+ /** Defines whether the contact view item is a contact group. */
+ enum TViewContactType
+ {
+ /** The contact view item is not a contact group. */
+ EContactItem,
+ /** The contact view item is a contact group (CContactGroup). */
+ EGroup
+ };
+ IMPORT_C CViewContact(TContactItemId aId);
+ IMPORT_C static CViewContact* NewL(const CViewContact& aContact);
+ IMPORT_C static CViewContact* NewLC(TContactItemId aId);
+ IMPORT_C static CViewContact* NewL(TContactItemId aId, TInt aLength);
+ static CViewContact* NewLC(RReadStream& aStream);
+
+ IMPORT_C ~CViewContact();
+ IMPORT_C void InternalizeL(RReadStream& aStream);
+ IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
+ IMPORT_C TInt ExternalizedSize() const;
+ IMPORT_C TInt FieldCount() const;
+ IMPORT_C TPtrC Field(TInt aPosition) const;
+ IMPORT_C TBool ContactMatchesFilter(TInt aFilter) const;
+ IMPORT_C void AddFieldL(const TDesC& aField);
+ IMPORT_C TBool IsSortable() const;
+ IMPORT_C void SetFirstFieldForBlankContactL(const TDesC& aFirstField);
+ IMPORT_C void Reset();
+ IMPORT_C TInt ContactHint() const;
+ IMPORT_C void SetContactHint(TInt aHint);
+ IMPORT_C TUid ContactTypeUid() const;
+ IMPORT_C void SetContactTypeUid(TUid aUid);
+
+ inline TContactItemId Id() const;
+ inline TViewContactType ContactType() const;
+public:
+ inline void SetId(TContactItemId aId);
+ inline void SetContactType(CViewContact::TViewContactType aContactType);
+ static TBool HintFieldMatchesFilter(TInt aHintField, TInt aFilter);
+ TPtrC FindFirstPopulatedField(TInt aOffset, TInt& aFoundPosition) const;
+
+#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__
+ IMPORT_C void ChangeToLightweightObject();
+ TBool IsLightweightObject() const;
+ void CopyL(const CViewContact& aContact);
+#endif //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+private:
+ void ConstructL(TInt aLength = 0);
+ void ConstructL(const CViewContact& aContact);
+ friend class CContactViewBase;
+private:
+ TContactItemId iId;
+ TViewContactType iContactType;
+ CViewContactExtension* iExtension;
+ RArray<TInt> iTextIndexes;
+ };
+
+
+/*
+ * A view can be named or un-named. An un-named view has a fixed sort order - the
+ * only way to change this is by closing the object and creating a new one with a
+ * different order. Named views may have their sort order changed. When this is
+ * done, first all observers will be informed that the view is 'unavailable'. This
+ * notification will be followed by 'sort order changed' and 'ready'. Only once
+ * the 'ready' notification has been received may the view be used again.
+ */
+class CContactViewBase : public CBase
+/** The abstract base class for all contact view classes.
+
+All contact views operate asynchronously, so users of the view must observe
+it, by implementing the MContactViewObserver interface. Immediately after
+construction, views are not in a usable state (the underlying data may be
+being sorted, for instance). Only after the user has received a TContactViewEvent::EReady
+event may the view be used.
+
+View observers are also notified when changes occur, for instance when the
+view's state changes (see TState), when an error occurs, or when an item is
+added or removed.
+@publishedAll
+@released
+*/
+ {
+public:
+ class CContactViewBaseExtension : public CBase
+ /** An extension class that holds member data added in v7.0s.
+
+ It was created for binary compatibility purposes.
+ @internalComponent
+ @released */
+ {
+ public:
+ static CContactViewBaseExtension* NewL();
+ ~CContactViewBaseExtension();
+
+ private:
+ CContactViewBaseExtension();
+ void ConstructL();
+
+ public:
+ /** A standard error code that is passed to view observers by NotifyObservers()
+ (unless its value is KErrNone). */
+ TInt iError;
+ /** The UID of the view's find configuration plug-in.
+
+ On construction, this is initialised to KNullUid.
+
+ The plug-in is loaded when ContactsMatchingCriteriaL(), ContactsMatchingPrefixL()
+ or MatchesCriteriaL() is called. */
+ TUid iFindPluginUid;
+ /** The UID of the view's sort plug-in. */
+ TUid iSortPluginUid;
+ private:
+ CContactViewFindConfigInterface* iFindPluginImpl;
+ CViewContactSortPlugin* iSortPluginImpl;
+ TCollationMethod iCollationMethod;
+ friend class CContactViewBase;
+ };
+ class TVirtualFunction1Params
+ /** Holds the two parameters passed to the helper method GetContactIdsL() from
+ the reserved function CContactViewBase_Reserved_1(). It has an inline constructor
+ to initialise the data members.
+ @publishedAll
+ @released */
+ {
+ public:
+ /** Inline constructor to initialize member data
+ @param aIndexes Pointer to an array of indexes in a view
+ @param aIdArray Pointer to array of contact IDs */
+ inline TVirtualFunction1Params(const CArrayFix<TInt>* aIndexes, CContactIdArray* aIdArray) :iIndexes(aIndexes), iIdArray(aIdArray){};
+ /** Pointer to an array of indexes in a view */
+ const CArrayFix<TInt>* iIndexes;
+ /** Pointer to array of contact IDs */
+ CContactIdArray* iIdArray;
+ };
+ class TVirtualFunction2Params
+ /** Holds the two parameters passed to the method GetContactsMatchingFilterL()
+ from the reserved function CContactViewBase_Reserved_1(). It has an inline
+ constructor to initialise the data members.
+ */
+ {
+ public:
+ /** Inline constructor to initialize member data.
+ @param aFilter Filter for the contacts
+ @param aMatchingContacts Contacts matching a particular criterion */
+ inline TVirtualFunction2Params(TInt aFilter, RArray<TContactIdWithMapping>& aMatchingContacts) : iFilter(aFilter), iMatchingContacts(aMatchingContacts){};
+ public:
+ /** Filter for the contacts. */
+ TInt iFilter;
+ /** List of contacts matching the criteria. */
+ RArray<TContactIdWithMapping>& iMatchingContacts;
+ };
+ class TVirtualFunction3Params
+ /** Holds the two parameters passed to the method InsertContactInView() from the
+ reserved function CContactViewBase_Reserved_1(). It has an inline
+ constructor to initialise the data members.
+
+ @internalAll */
+ {
+ public:
+ inline TVirtualFunction3Params(RPointerArray<CViewContact>& aContacts, const CViewContact* aNewContact) :iContacts(aContacts), iNewContact(aNewContact){};
+ RPointerArray<CViewContact>& iContacts;
+ const CViewContact* iNewContact;
+ };
+ /** Search type.
+
+ This controls whether a search term can occur anywhere in a contact item field,
+ or just at the beginning of the field. */
+ enum TSearchType
+ {
+ /** The search uses full wildcard matching so that the search string can occur anywhere
+ in the item's fields. */
+ EFullSearch,
+ /** The search uses partial wildcard matching so that the search string can only
+ occur at the beginning of the item's fields. */
+ EPrefixSearch
+ };
+ /** Identifies the functions that have been added to CContactViewBase, or that
+ may be added in the future. This identifier is passed to the reserved virtual
+ function CContactViewBase_Reserved_1() and enables the addition of new virtual
+ methods without breaking binary compatibility. */
+ enum TFunction
+ {
+ /** Identifies the function CContactViewBase::GetContactIdsL(). */
+ ECContactViewBaseVirtualFunction1,
+ /** Identifies the function CContactViewBase::GetContactsMatchingFilterL(). */
+ ECContactViewBaseVirtualFunction2,
+ // communication with Sort Plug-in
+ /** Identifies the function CContactViewBase::InsertContactInView(). */
+ ECContactViewBaseVirtualFunction3,
+ };
+protected:
+ /** Defines the contact view states. */
+ enum TState
+ {
+ /** The view is initialising.
+
+ This is the view's state immediately after construction or after a significant change
+ (e.g CurrentDatabaseChanged or UnknownChanges), indicating that it can't be used yet. */
+ EInitializing,
+ /** The view is ready to be used. */
+ EReady,
+ /** The view is not ready to be used, for instance immediately after the sort order
+ has changed, or after an error has occurred. */
+ ENotReady
+ };
+public:
+ IMPORT_C void OpenL(MContactViewObserver& aObserver);
+ IMPORT_C TInt Open(MContactViewObserver& aObserver);
+ IMPORT_C TBool Close(const MContactViewObserver& aObserver);
+ /** Returns the contact item ID at the specified index into the view.
+
+ @capability ReadUserData
+ @param aIndex Index of the contact item ID into the view.
+ @return The contact item ID. */
+ virtual TContactItemId AtL(TInt aIndex) const=0;
+ /** Returns the contact item at the specified index into the view.
+
+ @capability ReadUserData
+ @param aIndex Index of the contact item into the view.
+ @return The contact item. */
+ virtual const CViewContact& ContactAtL(TInt aIndex) const =0;
+ /** Returns the number of contact items in the view.
+
+ @capability ReadUserData
+ @return The number of contact items in the view. */
+ virtual TInt CountL() const=0;
+ /** Returns the index into the view of the specified contact item.
+
+ @capability ReadUserData
+ @param aId The contact item ID to search for.
+ @return The index into the view of the contact item ID, or KErrNotFound if
+ no matching ID can be found. */
+ virtual TInt FindL(TContactItemId aId) const=0;
+ /** Returns a descriptor containing the contents of all fields for an item in the view.
+
+ The field separator is used to separate the contents of each field. It is
+ not appended to the last field.
+
+ @capability ReadUserData
+ @param aIndex The index of the contact item into the view.
+ @param aSeparator The string to use to separate the fields.
+ @return Pointer to the contact item descriptor. */
+ virtual HBufC* AllFieldsLC(TInt aIndex,const TDesC& aSeparator) const=0;
+ IMPORT_C virtual void ContactsMatchingCriteriaL(const MDesCArray& aFindWords,RPointerArray<CViewContact>& aMatchedContacts);
+ /** Gets the view preferences.
+
+ @capability ReadUserData
+ @return The view preferences. */
+ virtual TContactViewPreferences ContactViewPreferences()=0;
+ /** Gets the view's sort order.
+
+ @capability ReadUserData
+ @return The sort order. */
+ virtual const RContactViewSortOrder& SortOrderL() const = 0;
+ IMPORT_C virtual void ContactsMatchingPrefixL(const MDesCArray& aFindWords, RPointerArray<CViewContact>& aMatchedContacts);
+ //This is a reserved virtual exported function that is used for BC proofing against present
+ //and future additions of new exported virtual functions. Existing exported virtual methods
+ //that broke BC are now non-virtual exported helper functions called from this method.
+ //All derived classes of CContactViewBase that are public must mandatorily
+ //implement this reserved exported virtual method.
+ IMPORT_C virtual TAny* CContactViewBase_Reserved_1(TFunction aFunction,TAny* aParams);
+ //New exported method to set the ECOM plug-in to be used
+ IMPORT_C void SetViewFindConfigPlugin(TUid aUid);
+ IMPORT_C TUid GetViewFindConfigPlugin();
+ IMPORT_C virtual void GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds);
+ IMPORT_C TInt Error() const;
+ IMPORT_C TUid GetViewSortPluginImplUid() const;
+
+protected:
+ IMPORT_C ~CContactViewBase();
+ IMPORT_C void ConstructL();
+
+ IMPORT_C CContactViewBase(const CContactDatabase& aDb);
+ IMPORT_C void NotifyObservers(const TContactViewEvent& aEvent);
+ IMPORT_C TInt NotifyObserverAsync(MContactViewObserver& aObserver,const TContactViewEvent& aEvent);
+ IMPORT_C static TBool IdsMatch(const CViewContact& aFirst,const CViewContact& aSecond);
+ IMPORT_C HBufC* FieldsWithSeparatorLC(const RPointerArray<CViewContact>& aContacts,TInt aIndex,const TDesC& aSeparator) const;
+ //Find helper functions
+ IMPORT_C virtual TBool MatchesCriteriaL(const CViewContact& aContact,const MDesCArray& aFindWords);
+ IMPORT_C static TBool MatchesCriteriaL(const CViewContact& aContact,const MDesCArray& aFindWords, TSearchType aSearchType);
+ IMPORT_C static TBool MatchesCriteriaL(const CViewContact& aContact,const MDesCArray& aFindWords, TSearchType aSearchType,CContactViewBase::CContactViewBaseExtension* aExtension);
+ IMPORT_C static TBool IdsEqual(const TContactIdWithMapping& aFirst,const TContactIdWithMapping& aSecond);
+ IMPORT_C static TBool IndexesEqual(const TContactIdWithMapping& aFirst,const TContactIdWithMapping& aSecond);
+ IMPORT_C static TInt CompareFieldsL(const CViewContact& aFirst, const CViewContact& aSecond);
+ // View Sort Plugin changes
+ IMPORT_C static TInt CompareContactIds(const CViewContact& aFirst, const CViewContact& aSecond);
+ IMPORT_C static TBool ContactIsSortable(const CViewContact& aContact);
+ IMPORT_C TInt CompareContactsAndIdsL(const CViewContact& aFirst, const CViewContact& aSecond) const;
+protected: // these are needed by CContactLocalView only
+ TInt InsertContactInView(RPointerArray<CViewContact>& aContacts, const CViewContact* aNewContact, TBool aSortByIdOnly, TInt* aIndex) const;
+ TBool IsContactSortable(const CViewContact& aContact, TContactViewPreferences& aViewPreferences) const;
+ CViewContactSortPlugin* SortPluginImpl() const;
+ TUid FindSortPluginImplL (const TDesC8& aSortPluginName,TBool aWildCard=EFalse) const;
+ TUid FindDefaultViewSortPluginImplL () const;
+ void LoadViewSortPluginL (TUid aSortPluginUid,TContactViewPreferences& aViewPreferences);
+
+private:
+ static TInt AsyncNotifyCallBack(TAny* aSelf);
+ static CDesCArrayFlat* CreateFindWordArrayLC(const MDesCArray& aFindWords, TSearchType aSearchType);
+ static TBool ContactMatchesCriteriaL(const CViewContact& aContact,const MDesCArray& aFindWords,CContactViewBase::CContactViewBaseExtension* aExtension);
+ void MatchContactsL(const MDesCArray& aFindWords,RPointerArray<CViewContact>& aMatchedContacts, TSearchType aSearchType);
+ static TInt CompareFieldsWithCollationLevel(const CViewContact& aFirst, const CViewContact& aSecond,
+ TInt aCollationLevel, TCollationMethod* aCollateMethod);
+ TInt GetErrorValueFromExtensionClass();
+ void GetContactsMatchingFilterL(TInt aFilter, RArray<TContactIdWithMapping>& aMatchingContacts);
+ TInt TextCompareFieldsL(const CViewContact& aFirst, const CViewContact& aSecond) const;
+
+
+private:
+ struct TObserverAndEvent
+ {
+ TContactViewEvent iAsyncEvent;
+ MContactViewObserver* iObserverToNotify;
+ };
+protected:
+ // Reference to CContactDatabase class.
+ const CContactDatabase& iDb;
+ // Different Contacts view states.
+ TState iState;
+ // The pointer to the ContactViewBase BC extension class.
+ CContactViewBaseExtension* iExtension;
+private:
+ RPointerArray<MContactViewObserver> iObserverArray;
+ CIdle* iAsyncNotifier;
+ RArray<TObserverAndEvent> iOutstandingNotifications;
+ };
+
+inline TInt CContactViewBase::GetErrorValueFromExtensionClass()
+ {
+ return iExtension->iError;
+ }
+
+class MLplPersistenceLayerFactory;
+
+#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__
+
+class CViewContactManager;
+
+#else //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+class CViewIterator;
+
+#endif //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+class CContactLocalView : public CContactViewBase, public MContactDbObserver
+/** An instantiable base class for contact views.
+
+The data associated with a local view is allocated within the client's memory
+space; CContactRemoteView should be used in preference if the view is likely
+to be shared between multiple clients. It is kept up to date by receiving
+change events from the underlying CContactDatabase object which it observes.
+The view preferences and sort order are specified on construction.
+@publishedAll
+@released
+*/
+ {
+public:
+ IMPORT_C static CContactLocalView* NewL(MContactViewObserver& aObserver,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes);
+ IMPORT_C static CContactLocalView* NewL(MContactViewObserver& aObserver,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,
+ const TDesC8& aSortPluginName);
+ IMPORT_C static CContactLocalView* NewL(MContactViewObserver& aObserver,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,
+ MLplPersistenceLayerFactory* aFactory,const TDesC8& aSortPluginName);
+
+ IMPORT_C const RContactViewSortOrder& SortOrder() const;
+public: // From CContactViewBase.
+ TContactItemId AtL(TInt aIndex) const;
+ TInt CountL() const;
+ TInt FindL(TContactItemId aId) const;
+ HBufC* AllFieldsLC(TInt aIndex,const TDesC& aSeparator) const;
+ const CViewContact& ContactAtL(TInt aIndex) const;
+ TContactViewPreferences ContactViewPreferences();
+ const RContactViewSortOrder& SortOrderL() const;
+ void NotifySortError(TInt aError);
+ //All derived classes of CContactViewBase that are public should mandatorily
+ //implement this reserved exported virtual method.
+ IMPORT_C TAny* CContactViewBase_Reserved_1(TFunction aFunction,TAny* aParams);
+protected:
+ IMPORT_C ~CContactLocalView();
+ IMPORT_C CContactLocalView(const CContactDatabase& aDb,TContactViewPreferences aContactTypes);
+ CContactLocalView(const CContactDatabase& aDb,TContactViewPreferences aContactTypes,MLplPersistenceLayerFactory* aIterFactory);
+ IMPORT_C void ConstructL(MContactViewObserver& aObserver,const RContactViewSortOrder& aSortOrder);
+ void ConstructL(MContactViewObserver& aObserver,const RContactViewSortOrder& aSortOrder, const TBool aUseNamedPlugin, const TDesC8& aSortPluginName);
+ IMPORT_C virtual void SortL(const RContactViewSortOrder& aSortOrder);
+ IMPORT_C virtual TInt InsertL(TContactItemId aId);
+ IMPORT_C virtual TInt RemoveL(TContactItemId aId);
+protected:
+ void SetState(TState aState);
+private: // From MContactDbObserver.
+ virtual void HandleDatabaseEventL(TContactDbObserverEvent aEvent);
+
+private:
+
+#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__
+ void SortComplete(TInt aSortErr);
+ void SetSortOrderL(const RContactViewSortOrder& aSortOrder);
+ void SortL();
+ void SafeResort();
+ friend class CViewContactManager;
+#else //__SYMBIAN_CNTMODEL_USE_SQLITE__
+ TInt SortCallBack();
+ TInt DoReadIncrementL();
+ void ResetSortL();
+ void InitialiseSortL(const RContactViewSortOrder& aSortOrder, TBool aChangingSortOrder);
+ void SortL();
+ void SafeResort();
+ void ContactsArraySortL();
+ TBool ContactCorrectType(TUid aType,TContactViewPreferences aTypeToInclude);
+#endif //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+private: // Metheds for event handling
+ void HandleOutstandingEvents();
+ void HandleOutstandingEventL();
+ friend class CIdleContactSorter;
+protected:
+ /** The sort order.
+ This is set during construction or when SortL() is called. */
+ RContactViewSortOrder iSortOrder ;
+private:
+ IMPORT_C virtual void CContactLocalView_Reserved_1();
+ IMPORT_C virtual void CContactLocalView_Reserved_2();
+
+private:
+ MLplPersistenceLayerFactory* iFactory;
+ RPointerArray<CViewContact> iContacts;
+ RPointerArray<CViewContact> iUnSortedContacts;
+ RArray<TContactDbObserverEvent> iOutstandingEvents;
+ CIdleContactSorter* iAsyncSorter;
+
+#ifdef __SYMBIAN_CNTMODEL_USE_SQLITE__
+ CViewContactManager* iViewCntMgr;
+#else //__SYMBIAN_CNTMODEL_USE_SQLITE__
+ CViewIterator* iViewIterator;
+#endif //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+ CContactTextDef* iTextDef;
+ TContactViewPreferences iViewPreferences;
+ TBool iSpare0;
+ TInt iSpare;
+ };
+
+class RContactRemoteView : public RSubSessionBase
+/** This class is used internally by remote contact views as the handle to the
+server side view object.
+
+@see CContactRemoteViewBase
+@internalComponent
+@released
+*/
+ {
+public:
+ void OpenL(const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,const TUid& aSortPluginImplUid,const TDesC8& aSortPluginName);
+ void OpenL(const CContactDatabase& aDb,const TDesC& aName,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,const TUid& aSortPluginImplUid,const TDesC8& aSortPluginName);
+ void Close();
+public: // From CContactViewBase
+ TContactItemId AtL(TInt aIndex) const;
+ CViewContact* ContactAtL(TInt aIndex);
+ TInt CountL() const;
+ TInt FindL(TContactItemId aId) const;
+ HBufC* AllFieldsLC(TInt aIndex,const TDesC& aSeparator) const;
+ const RContactViewSortOrder& SortOrderL();
+public:
+ void ContactsMatchingCriteriaL(const MDesCArray& aFindWords,RPointerArray<CViewContact>& aMatchedContacts, TBool aPrefixSearch,TUid aUid);
+ void ChangeSortOrderL(const RContactViewSortOrder& aSortOrder);
+ void GetSortOrderL(RContactViewSortOrder& aSortOrder);
+ TContactViewPreferences ContactViewPreferencesL();
+
+ void RequestViewEvent(TPckgBuf<TContactViewEvent>& aEvent,TRequestStatus& aStatus);
+ TInt CancelRequestViewEvent();
+ void GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds);
+ void GetContactsMatchingFilterL(TInt aFilter, RArray<TContactIdWithMapping>& aMatchingContacts);
+ TUid GetViewSortPluginImplUidL() const;
+private:
+ HBufC8* PackageSortOrderLC(const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes) const;
+ HBufC8* PackageSortOrderAndPluginDetailsLC(const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,const TUid& aSortPluginImplUid,const TDesC8& aSortPluginName) const;
+private:
+ CViewContact* iContact;
+ RContactViewSortOrder iSortOrder ;
+ };
+
+
+NONSHARABLE_CLASS(CContactRemoteViewBase) : public CContactViewBase
+/** Base class for all remote contact view classes.
+
+It implements all the pure virtual functions in CContactViewBase and additionally
+it handles remote view notifications. The data associated with remote views
+is allocated within the memory space of the contacts server. This means that
+multiple clients can share the same server side view object, thereby reducing
+the overhead associated with initial sorting of the view data and keeping
+it in sync with the underlying data. Remote views should therefore be used
+when the same view is likely to be needed by more than one client.
+@internalComponent
+@released
+*/
+ {
+public: // From CContactViewBase.
+ TContactItemId AtL(TInt aIndex) const;
+ TInt CountL() const;
+ TInt FindL(TContactItemId aId) const;
+ HBufC* AllFieldsLC(TInt aIndex,const TDesC& aSeparator) const;
+ const CViewContact& ContactAtL(TInt aIndex) const;
+ TContactViewPreferences ContactViewPreferences();
+ void ContactsMatchingCriteriaL(const MDesCArray& aFindWords,RPointerArray<CViewContact>& aMatchedContacts);
+ void ContactsMatchingPrefixL(const MDesCArray& aFindWords, RPointerArray<CViewContact>& aMatchedContacts);
+ const RContactViewSortOrder& SortOrderL() const;
+ //All derived classes of CContactViewBase that are public should mandatorily
+ //implement this reserved exported virtual method.
+ TAny* CContactViewBase_Reserved_1(TFunction aFunction,TAny* aParams);
+ //This function was virtual in a previous release, if you still need to use it
+ //in a virtual way then you can call it via the Reserved function.
+ //The functionality of this function ,however,remains the same.
+ void GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds);
+ void GetContactsMatchingFilterL(TInt aFilter, RArray<TContactIdWithMapping>& aMatchingContacts);
+protected:
+ ~CContactRemoteViewBase();
+ CContactRemoteViewBase(const CContactDatabase& aDb);
+ void ConstructL(MContactViewObserver& aObserver);
+private:
+ static TInt NotifierCallBack(TAny* aSelf);
+ void HandleContactViewEvent(const TContactViewEvent& aEvent);
+protected:
+ /** A handle to the server side view. */
+ RContactRemoteView iView;
+private:
+ CContactRemoteViewNotifier* iNotifier;
+ /** Cached copy of the count of the local view in the contacts server.
+ If this is KCachedItemCountInvalid then next time CountL is called
+ the current count is retrieved from the contacts server. */
+ mutable TInt iCount;
+ };
+
+
+class CContactRemoteView : public CContactRemoteViewBase
+/** An instantiable remote contact view class.
+
+Remote views are associated with a CContactLocalView object held in the contacts
+server. They provide an efficient means for multiple clients to share the
+same underlying view.
+
+The view preferences and sort order are specified on construction.
+@publishedAll
+@released
+*/
+ {
+public:
+ IMPORT_C static CContactRemoteView* NewL(MContactViewObserver& aObserver,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes);
+ IMPORT_C static CContactRemoteView* NewL(MContactViewObserver& aObserver,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,
+ const TDesC8& aSortPluginName);
+ IMPORT_C void GetSortOrderL(RContactViewSortOrder& aSortOrder);
+ //All derived classes of CContactViewBase that are public should mandatorily
+ //implement this reserved exported virtual method.
+ TAny* CContactViewBase_Reserved_1(TFunction aFunction,TAny* aParams);
+protected:
+ ~CContactRemoteView();
+ CContactRemoteView(const CContactDatabase& aDb);
+private:
+ void ConstructL(MContactViewObserver& aObserver,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes);
+ void ConstructL(MContactViewObserver& aObserver,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypesconst, const TDesC8& aSortPluginName);
+ };
+
+
+class CContactNamedRemoteView : public CContactRemoteView
+/** A named remote contact view.
+
+This class enables multiple clients to share a named server side view. It
+also provides a function to change the sort order. If the sort order is changed,
+a notification is sent to all users of the named view.
+@publishedAll
+@released
+*/
+ {
+public:
+ IMPORT_C static CContactNamedRemoteView* NewL(MContactViewObserver& aObserver,const TDesC& aName,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes);
+ IMPORT_C static CContactNamedRemoteView* NewL(MContactViewObserver& aObserver,const TDesC& aName,const CContactDatabase& aDb,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes,
+ const TDesC8& aSortPluginName);
+ IMPORT_C void ChangeSortOrderL(const RContactViewSortOrder& aSortOrder);
+ //All derived classes of CContactViewBase that are public should mandatorily
+ //implement this reserved exported virtual method.
+ TAny* CContactViewBase_Reserved_1(TFunction aFunction,TAny* aParams);
+private:
+ ~CContactNamedRemoteView();
+ CContactNamedRemoteView(const CContactDatabase& aDb);
+ void ConstructL(MContactViewObserver& aObserver,const TDesC& aName,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes);
+ void ConstructL(MContactViewObserver& aObserver,const TDesC& aName,const RContactViewSortOrder& aSortOrder,TContactViewPreferences aContactTypes, const TDesC8& aSortPluginName);
+ };
+
+inline TContactViewEvent::TContactViewEvent()
+/** Empty default constructor. */
+ {};
+
+inline TContactViewEvent::TContactViewEvent(TEventType aEventType,TInt aInt,TContactItemId aContactId) : iEventType(aEventType),iInt(aInt),iContactId(aContactId)
+/** Constructor with an event type and an optional error code and contact item ID.
+
+@param aEventType The event type.
+@param aInt Optional standard error code.
+@param aContactId Optional contact item ID. */
+ {};
+
+inline void RContactViewSortOrder::AppendL(TFieldType aField)
+/** Appends a field type to the sort order object.
+
+@param aField The field type to append. */
+ { User::LeaveIfError(iFields.Append(aField)); }
+
+inline TFieldType RContactViewSortOrder::operator[](TInt aIndex) const
+/** Gets an indexed field type.
+
+@param aIndex Index of the required field type. A panic occurs if this is
+invalid.
+@return The field type located at the indexed position in the array. */
+ { return iFields[aIndex]; }
+
+inline TInt RContactViewSortOrder::Count() const
+/** Gets the number of field types in the sort order array.
+
+@return The number of field types in the array. */
+ { return iFields.Count(); }
+
+inline TContactItemId CViewContact::Id() const
+/** Gets the view item's ID.
+
+@return The view item's ID. */
+ {return iId;}
+
+inline CViewContact::TViewContactType CViewContact::ContactType() const
+/** Gets the view item's type.
+
+@return The view item's type. */
+ {return iContactType;}
+
+inline void CViewContact::SetId(TContactItemId aId)
+/** Sets the view item's ID.
+
+@param aId The contact item ID. */
+ {iId=aId;}
+
+inline void CViewContact::SetContactType(CViewContact::TViewContactType aContactType)
+/** Sets the view item's type.
+
+@param aContactType The view item's type. */
+ {iContactType=aContactType;}
+#endif