diff -r 000000000000 -r e686773b3f54 pimprotocols/phonebooksync/inc/PhonebookManager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimprotocols/phonebooksync/inc/PhonebookManager.h Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,264 @@ +// Copyright (c) 2002-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: +// Header file for Phonebook Synchroniser's CPhoneBookManager class which +// manages the parameters for the phone and each phonebook, including the +// Look-Up Tables, Phonebook store handles and flags for the synchroniser +// engine. +// This class can be accessed from either the server side or engine side. +// All applicable functions are mutex protected to prevent corruption from +// being accessed simutantiously from two threads. CPhoneBook is not protected +// hence why CPhoneBookManager does not give out the CPhoneBook object pointers, +// but performs all operations itself, with mutex protection. +// +// + +/** + @file + @internalComponent +*/ + +#ifndef __PHONEBOOKMANAGER_H__ +#define __PHONEBOOKMANAGER_H__ + +#include "phbksync.h" +#include "phbksynclog.h" +#include "Phonebook.h" +#include "PhonebookIniFile.h" + + +/** + * This class holds data relating to the phonebooks. This includes the + * current PIN status and security settings, as well as a table of parameters + * associated with each phonebook. Each entry in this table consists of a + * CPhoneBook class. + * + * The server owns a instance of this class, while the engine has a reference + * to it. The data is protected from thread corruption by a mutex. + */ +class CPhoneBookManager : public CBase + { +public: + static CPhoneBookManager* NewL(TUint32 aICCCaps); + ~CPhoneBookManager(); + + // + // Basic management of phonebook UIDs. These do not require shared-data + // mutex protection as the will not change after construction. + // + inline TInt ValidatePhonebookUid(TUid aPhonebookUid) const; + inline TInt GetPhonebookCount() const; + inline TInt GetPhonebookUid(TInt aPosition, TUid& aPhonebookUid) const; + + // + // General settings for all phonebooks. Since the data can change, the + // functions use mutex protection. + // + TUid GetPhonebookUidFromContactId(TContactItemId aContactId); + TUid GetPhonebookUidFromTemplateId(TContactItemId aGroupId); + + void GetPin1LockStatus(RMobilePhone::TMobilePhoneLockStatus& aLockStatus); + void SetPin1LockStatus(RMobilePhone::TMobilePhoneLockStatus aLockStatus); + + void GetPin2LockStatus(RMobilePhone::TMobilePhoneLockStatus& aLockStatus); + void SetPin2LockStatus(RMobilePhone::TMobilePhoneLockStatus aLockStatus); + + void GetHiddenKeyLockStatus(RMobilePhone::TMobilePhoneLockStatus& aLockStatus); + void SetHiddenKeyLockStatus(RMobilePhone::TMobilePhoneLockStatus aLockStatus); + + void GetUsimAppLockStatus(RMobilePhone::TMobilePhoneLockStatus& aLockStatus); + void SetUsimAppLockStatus(RMobilePhone::TMobilePhoneLockStatus aLockStatus); + + void GetUsimUniversalPinLockStatus(RMobilePhone::TMobilePhoneLockStatus& aLockStatus); + void SetUsimUniversalPinLockStatus(RMobilePhone::TMobilePhoneLockStatus aLockStatus); + + void RecordSecurityEvent(RMobilePhone::TMobilePhoneSecurityEvent aSecurityEvent); + + TBool IsPin1Valid(); + TBool IsPin2Valid(); + TBool IsUsimAppPinValid(); + + // + // Settings that are per phonebook. These functions are all mutex + // protected. + // + TInt GetPhBkInfoRetrievedResult(TUid aPhonebookUid, TInt& aErrorCode); + TInt SetPhBkInfoRetrievedResult(TUid aPhonebookUid, TInt aErrorCode); + + TInt GetSyncMode(TUid aPhonebookUid, RPhoneBookSession::TPhonebookSyncMode& aSyncMode); + TInt SetSyncMode(TUid aPhonebookUid, RPhoneBookSession::TPhonebookSyncMode aSyncMode); + + TInt GetSyncState(TUid aPhonebookUid, RPhoneBookSession::TSyncState& aSyncState); + TInt SetSyncState(TUid aPhonebookUid, RPhoneBookSession::TSyncState aSyncState); + + TInt GetLastSyncError(TUid aPhonebookUid, TInt& aLastSyncError); + TInt SetLastSyncError(TUid aPhonebookUid, TInt aLastSyncError); + + TInt GetTemplateId(TUid aPhonebookUid, + TContactItemId& aTemplateId); + TInt SetTemplateId(TUid aPhonebookUid, + TContactItemId aTemplateId); + + TInt GetGroupId(TUid aPhonebookUid, + TContactItemId& aGroupId); + TInt SetGroupId(TUid aPhonebookUid, + TContactItemId aGroupId); + + TInt GetContactFields(TUid aPhonebookUid, + RPhoneBookSession::TContactFieldsV3& aContactFields); + TInt SetContactFields(TUid aPhonebookUid, + const RPhoneBookSession::TContactFieldsV3& aContactFields); + + TInt GetPhoneBookStore(TUid aPhonebookUid, + RMobilePhone& aPhone, + RMobilePhoneBookStore& aPhonebookStore); + TInt ClosePhoneBookStores(); + + TInt GetPhoneBookInfo(TUid aPhonebookUid, + RMobilePhoneBookStore::TMobilePhoneBookInfoV5& aPhBkInfo); + TInt SetPhoneBookInfo(TUid aPhonebookUid, + const RMobilePhoneBookStore::TMobilePhoneBookInfoV5& aPhBkInfo); + TInt AdjustPhoneBookInfoUsedEntries(TUid aPhonebookUid, TInt aChange); + + TInt GetLookUpTableSize(TUid aPhonebookUid, TInt& aSize); + TInt SetLookUpTableSize(TUid aPhonebookUid, TInt aSize); + TInt ClearLookUpTable(TUid aPhonebookUid); + + TInt IsEntryInTable(TUid aPhonebookUid, TContactItemId aContactId); + TInt UpdateEntryInTable(TUid aPhonebookUid, TInt aSlotNum, + TContactItemId aContactId); + TInt UpdateEntryInTable(TUid aPhonebookUid, TInt aSlotNum, + TContactItemId aContactId, + TPhonebookSlotState aSlotState); + + TInt GetContactIdFromSlotNum(TUid aPhonebookUid, TInt aSlotNum, + TContactItemId& aContactItemId); + TInt GetSlotNumFromContactId(TUid aPhonebookUid, + TContactItemId aContactId, + TInt& aSlotNum); + + TInt GetNumFreeSlots(TUid aPhonebookUid, TInt& aNumOfFreeSlots); + TInt GetFirstEmptySlot(TUid aPhonebookUid, TInt& aSlotNum); + TInt GetMatchingEntries(TUid aPhonebookUid, TPhonebookSlotState aSlotState, + RArray& aEntries); + + TInt LogLookUpTable(TUid aPhonebookUid); + +private: + CPhoneBookManager(); + + void ConstructL(TUint32 aICCCaps); + TInt GetPhonebook(TUid aPhonebookUid, CPhoneBook*& aPhoneBookPtr) const; + inline void AcquireMutex(); + inline void ReleaseMutex(); + + RMutex iMutex; + RPointerArray iPhonebookList; + CPhoneBookIniFile* iIniFile; + TBool iIsPuk1Verified; + RMobilePhone::TMobilePhoneLockStatus iPin1LockStatus; + RMobilePhone::TMobilePhoneLockStatus iPin2LockStatus; + RMobilePhone::TMobilePhoneLockStatus iHiddenKeyLockStatus; + RMobilePhone::TMobilePhoneLockStatus iUsimAppLockStatus; + RMobilePhone::TMobilePhoneLockStatus iUsimUniversalPinLockStatus; + }; + + +/** + * Validates a phonebook UID as being supported by the Phonebook + * Synchroniser with the current phone. This does not mean that + * the phonebook is supported by the phone, but that PhBkSync + * can use it. + * + * @param aPhonebookUid UID of the phonebook to validate. + * + * @return Returns KErrNone if valid, a system error code otherwise. + */ +inline TInt CPhoneBookManager::ValidatePhonebookUid(TUid aPhonebookUid) const + { + // + // Validate the UID by getting the parameters for the phonebook. If + // the UID is not valid, then it won't be found. + // + CPhoneBook* phonebookParams; + TInt result = GetPhonebook(aPhonebookUid, phonebookParams); + + return result; + } // CPhoneBookManager::ValidatePhonebookUid + + +/** + * Returns the number of phonebooks supported by the Phonebook Synchroniser + * using the current phone. + * + * @return Number of phonebooks supported. + * + * @see CPhoneBookManager::GetPhonebookUid + */ +inline TInt CPhoneBookManager::GetPhonebookCount() const + { + return iPhonebookList.Count(); + } // CPhoneBookManager::GetPhonebookCount + + +/** + * Get the phonebook UID for a particular index in the list of phonebooks. + * This can be used to iterate the list of phonebooks. + * + * @param aPosition Index of the phonebook in the list. + * @param aPhonebookUid Set with the phonebook UID on successful exit. + * + * @return Returns KErrNone if successful, a system error code otherwise. + * + * @see CPhoneBookManager::GetPhonebookCount() + */ +inline TInt CPhoneBookManager::GetPhonebookUid(TInt aPosition, + TUid& aPhonebookUid) const + { + // + // Check the position is valid and if so the return the UID... + // + if (aPosition < 0 || aPosition >= iPhonebookList.Count()) + { + return KErrArgument; + } + + aPhonebookUid = iPhonebookList[aPosition]->GetPhonebookUid(); + + return KErrNone; + } // CPhoneBookManager::GetPhonebookUid + + +/** + * Acquires the process local mutex used to protect the shared data. + */ +inline void CPhoneBookManager::AcquireMutex() + { + LOGPARAMS2(_L8("AcquireMutex(): Thread ID=%d"), (TUint) RThread().Id()); + + iMutex.Wait(); + } // CPhoneBookManager::AcquireMutex + + +/** + * Releases the process local mutex used to protect the shared data. + */ +inline void CPhoneBookManager::ReleaseMutex() + { + LOGPARAMS2(_L8("ReleaseMutex(): Thread ID=%d"), (TUint) RThread().Id()); + + iMutex.Signal(); + } // CPhoneBookManager::ReleaseMutex + + +#endif // __PHONEBOOKMANAGER_H__