// 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<TInt>& 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<CPhoneBook> 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__