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

//

#include "cphonebookdispatcher.h"

#include <ctsy/ltsy/mltsydispatchphonebookinterface.h>

#include <ctsy/pluginapi/mmmessagemanagercallback.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <ctsy/ltsy/ltsylogger.h>

#include "ctsydispatcherpanic.h"

#include "tdispatcherholder.h"

#include <ctsy/serviceapi/cmmgsmphonestorageutility.h> //for CStorageInfoData

#include <ctsy/ltsy/cphonebookentry.h>

#include <mpbutil.h>

#include <ctsy/serviceapi/cmmgsmphonestorageutility.h>

CPhonebookDispatcher::CPhonebookDispatcher(

		MLtsyDispatchFactoryV1& aLtsyFactory,

		MmMessageManagerCallback& aMessageManagerCallback,

		CRequestQueueOneShot& aRequestAsyncOneShot)

	: 	iLtsyFactoryV1(aLtsyFactory),

		iMessageManagerCallback(aMessageManagerCallback),

		iRequestAsyncOneShot(aRequestAsyncOneShot),

		iPhonebookCachePtrs(KPhonebookTypes),

		iPhonebookReadPtrs(KPhonebookTypes),

		iInitialisePhonebook(DispatcherPhonebook::EUnknown)

	{

	} // CPhonebookDispatcher::CPhonebookDispatcher

CPhonebookDispatcher::~CPhonebookDispatcher()

	{

	iPhonebookCachePtrs.Reset();

	iPhonebookReadPtrs.Reset();

	if(iSmsListArray)

		{

		iSmsListArray->ResetAndDestroy();

		}

	delete iSmsListArray;

	} // CPhonebookDispatcher::~CPhonebookDispatcher

CPhonebookDispatcher* CPhonebookDispatcher::NewLC(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CPhonebookDispatcher* self =

		new (ELeave) CPhonebookDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	} // CPhonebookDispatcher::NewLC

CPhonebookDispatcher* CPhonebookDispatcher::NewL(

	MLtsyDispatchFactoryV1& aLtsyFactory,

	MmMessageManagerCallback& aMessageManagerCallback,

	CRequestQueueOneShot& aRequestAsyncOneShot)

	{

	TSYLOGENTRYEXIT;

	CPhonebookDispatcher* self =

		CPhonebookDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);

	CleanupStack::Pop (self);

	return self;

	} // CPhonebookDispatcher::NewL

void CPhonebookDispatcher::ConstructL()

/**

 * Second phase constructor.

 */

	{

	TSYLOGENTRYEXIT;

	iSmsListArray = new ( ELeave ) CArrayPtrFlat< TSmsMsg >( 1 );

	// Get the Licensee LTSY interfaces related to Phonebook functionality

	// from the factory

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId))

		{

		TAny* storeReadEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreReadEntry::KLtsyDispatchPhonebookStoreReadEntryApiId,

		       	storeReadEntryInterface);

		iLtsyDispatchPhonebookStoreReadEntry =

				static_cast<MLtsyDispatchPhonebookStoreReadEntry*>(storeReadEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreReadEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreDeleteEntry::KLtsyDispatchPhonebookStoreDeleteEntryApiId))

		{

		TAny* storeDeleteEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreDeleteEntry::KLtsyDispatchPhonebookStoreDeleteEntryApiId,

		       	storeDeleteEntryInterface);

		iLtsyDispatchPhonebookStoreDeleteEntry =

				static_cast<MLtsyDispatchPhonebookStoreDeleteEntry*>(storeDeleteEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreDeleteEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId))

		{

		TAny* storeCacheInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreCache::KLtsyDispatchPhonebookStoreCacheApiId,

		       	storeCacheInterface);

		iLtsyDispatchPhonebookStoreCache =

				static_cast<MLtsyDispatchPhonebookStoreCache*>(storeCacheInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreCache, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreGetPhonebookInfo::KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId))

		{

		TAny* storeGetPhonebookInfoInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreGetPhonebookInfo::KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId,

		       	storeGetPhonebookInfoInterface);

		iLtsyDispatchPhonebookStoreGetPhonebookInfo =

				static_cast<MLtsyDispatchPhonebookStoreGetPhonebookInfo*>(storeGetPhonebookInfoInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreGetPhonebookInfo, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId))

		{

		TAny* storeInitialiseInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreInitialise::KLtsyDispatchPhonebookStoreInitialiseApiId,

		       	storeInitialiseInterface);

		iLtsyDispatchPhonebookStoreInitialise =

				static_cast<MLtsyDispatchPhonebookStoreInitialise*>(storeInitialiseInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreInitialise, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreDeleteAll::KLtsyDispatchPhonebookStoreDeleteAllApiId))

		{

		TAny* storeDeleteAllInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreDeleteAll::KLtsyDispatchPhonebookStoreDeleteAllApiId,

		       	storeDeleteAllInterface);

		iLtsyDispatchPhonebookStoreDeleteAll =

				static_cast<MLtsyDispatchPhonebookStoreDeleteAll*>(storeDeleteAllInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreDeleteAll, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId))

		{

		TAny* smsStoreReadAllInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreReadAll::KLtsyDispatchPhonebookSmsStoreReadAllApiId,

		       	smsStoreReadAllInterface);

		iLtsyDispatchPhonebookSmsStoreReadAll =

				static_cast<MLtsyDispatchPhonebookSmsStoreReadAll*>(smsStoreReadAllInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreReadAll, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreWriteEntry::KLtsyDispatchPhonebookStoreWriteEntryApiId))

		{

		TAny* storeWriteEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreWriteEntry::KLtsyDispatchPhonebookStoreWriteEntryApiId,

		       	storeWriteEntryInterface);

		iLtsyDispatchPhonebookStoreWriteEntry =

				static_cast<MLtsyDispatchPhonebookStoreWriteEntry*>(storeWriteEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreWriteEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId))

		{

		TAny* getPhoneStoreInfoInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookGetPhoneStoreInfo::KLtsyDispatchPhonebookGetPhoneStoreInfoApiId,

		       	getPhoneStoreInfoInterface);

		iLtsyDispatchPhonebookGetPhoneStoreInfo =

				static_cast<MLtsyDispatchPhonebookGetPhoneStoreInfo*>(getPhoneStoreInfoInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookGetPhoneStoreInfo, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId))

		{

		TAny* smsStoreDeleteEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreDeleteEntry::KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId,

		       	smsStoreDeleteEntryInterface);

		iLtsyDispatchPhonebookSmsStoreDeleteEntry =

				static_cast<MLtsyDispatchPhonebookSmsStoreDeleteEntry*>(smsStoreDeleteEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreDeleteEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId))

		{

		TAny* smsStoreDeleteAllInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreDeleteAll::KLtsyDispatchPhonebookSmsStoreDeleteAllApiId,

		       	smsStoreDeleteAllInterface);

		iLtsyDispatchPhonebookSmsStoreDeleteAll =

				static_cast<MLtsyDispatchPhonebookSmsStoreDeleteAll*>(smsStoreDeleteAllInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreDeleteAll, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId))

		{

		TAny* smsStoreGetInfoInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreGetInfo::KLtsyDispatchPhonebookSmsStoreGetInfoApiId,

		       	smsStoreGetInfoInterface);

		iLtsyDispatchPhonebookSmsStoreGetInfo =

				static_cast<MLtsyDispatchPhonebookSmsStoreGetInfo*>(smsStoreGetInfoInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreGetInfo, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId))

		{

		TAny* smsStoreReadEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreReadEntry::KLtsyDispatchPhonebookSmsStoreReadEntryApiId,

		       	smsStoreReadEntryInterface);

		iLtsyDispatchPhonebookSmsStoreReadEntry =

				static_cast<MLtsyDispatchPhonebookSmsStoreReadEntry*>(smsStoreReadEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreReadEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId))

		{

		TAny* smsStoreWriteEntryInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId,

		       	smsStoreWriteEntryInterface);

		iLtsyDispatchPhonebookSmsStoreWriteEntry =

				static_cast<MLtsyDispatchPhonebookSmsStoreWriteEntry*>(smsStoreWriteEntryInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookSmsStoreWriteEntry, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchPhonebookFuncUnitId, MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId))

		{

		TAny* storeCacheCancelInterface = NULL;

		iLtsyFactoryV1.GetDispatchHandler(

		       	MLtsyDispatchPhonebookStoreCacheCancel::KLtsyDispatchPhonebookStoreCacheCancelApiId,

		       	storeCacheCancelInterface);

		iLtsyDispatchPhonebookStoreCacheCancel =

				static_cast<MLtsyDispatchPhonebookStoreCacheCancel*>(storeCacheCancelInterface);

        __ASSERT_DEBUG(iLtsyDispatchPhonebookStoreCacheCancel, CtsyDispatcherPanic(EInvalidNullPtr));

  		}

	for(TInt i = 0; i < KPhonebookTypes; ++i)

		{

		iPhonebookCachePtrs.AppendL(NULL); //really only Fdn and Adn pointers will be stored with the current CTSY

		iPhonebookReadPtrs.AppendL(NULL);

		}

	} // CPhonebookDispatcher::ConstructL

CPhoneBookStoreEntry* CPhonebookDispatcher::CreatePhoneBookStoreEntryLC(const CPhoneBookEntry& aPhoneBookEntry) const

/**

 * Creates a CTSY CPhoneBookStoreEntry from a dispatcher CPhoneBookEntry, the created

 * entry is left on the cleanup stack.

 * 

 * @param aPhoneBookEntry The entry to create a CPhoneBookStoreEntry from.

 * @return A pointer to the created CTSY entry.

 */

	{

	CPhoneBookStoreEntry* ctsyPhoneBookStoreEntry = new (ELeave) CPhoneBookStoreEntry();

	CleanupStack::PushL(ctsyPhoneBookStoreEntry);

	ctsyPhoneBookStoreEntry->ConstructL();

	//the record number

	ctsyPhoneBookStoreEntry->iLocation = aPhoneBookEntry.GetIndex();

	//allocate the buffer and copy the name

	ctsyPhoneBookStoreEntry->iText = HBufC::NewL(aPhoneBookEntry.GetFirstName().Length());

	*(ctsyPhoneBookStoreEntry->iText) = aPhoneBookEntry.GetFirstName();

	//allocate the buffer and copy the dialling number

	ctsyPhoneBookStoreEntry->iNumber = HBufC::NewL(aPhoneBookEntry.GetDiallingNumber().Length());

	*(ctsyPhoneBookStoreEntry->iNumber) = aPhoneBookEntry.GetDiallingNumber();

	TInt i = 0;

	//add the email address's

	const TInt KEmailAddresssCount = aPhoneBookEntry.GetEmailAddresss().Count();

	for (i = 0; i < KEmailAddresssCount; ++i)

		{

		ctsyPhoneBookStoreEntry->iEmail->AppendL(aPhoneBookEntry.GetEmailAddresss()[i]);

		}

	//add the second names

	const TInt KSecondNamesCount = aPhoneBookEntry.GetSecondNames().Count();

	for (i = 0; i < KSecondNamesCount; ++i)

		{

		ctsyPhoneBookStoreEntry->iSne->AppendL(aPhoneBookEntry.GetSecondNames()[i]);

		}

	//add the additional numbers

	const TInt KAdditionalNumbersCount = aPhoneBookEntry.GetAdditionalNumbers().Count();

	for (i = 0; i < KAdditionalNumbersCount; ++i)

		{

		ctsyPhoneBookStoreEntry->iAnr->AppendL(aPhoneBookEntry.GetAdditionalNumbers()[i]);

		}

	return ctsyPhoneBookStoreEntry;

	}

TInt CPhonebookDispatcher::FillPhoneBookEntry(const CPhoneBookStoreEntry& aPhoneBookStoreEntry, CPhoneBookEntry& aPhoneBookEntry) const

/**

 * Fills a dispatcher CPhoneBookEntry from a CTSY CPhoneBookStoreEntry.

 * 

 * @param aPhoneBookStoreEntry The CTSY phonebook entry to read from.

 * @param aPhoneBookEntry The dispatcher entry to be written to.

 * @return Error code, KErrNone is successful.

 */

	{

	TInt error = KErrNone;

	aPhoneBookEntry.SetIndex(aPhoneBookStoreEntry.iLocation);

	if(aPhoneBookStoreEntry.iText && (error == KErrNone))

		{

		error = aPhoneBookEntry.SetFirstName(*aPhoneBookStoreEntry.iText);

		}

	if(aPhoneBookStoreEntry.iNumber && (error == KErrNone))

		{

		error = aPhoneBookEntry.SetDiallingNumber(*aPhoneBookStoreEntry.iNumber);

		}

	if(aPhoneBookStoreEntry.iEmail && (error == KErrNone))

		{

		const TInt KEmailCount = aPhoneBookStoreEntry.iEmail->MdcaCount();

		for(TInt i = 0; i < KEmailCount && (error == KErrNone); ++i)

			{

			error = aPhoneBookEntry.AddEmailAddress(aPhoneBookStoreEntry.iEmail->MdcaPoint(i));

			}

		}

	if(aPhoneBookStoreEntry.iSne && (error == KErrNone))

		{

		const TInt KSecondNameCount = aPhoneBookStoreEntry.iSne->MdcaCount();

		for(TInt i = 0; i < KSecondNameCount && (error == KErrNone); ++i)

			{

			error = aPhoneBookEntry.AddSecondName(aPhoneBookStoreEntry.iSne->MdcaPoint(i));

			}

		}

	if(aPhoneBookStoreEntry.iAnr && (error == KErrNone))

		{

		const TInt KAdditionalNumberCount = aPhoneBookStoreEntry.iAnr->MdcaCount();

		for(TInt i = 0; i < KAdditionalNumberCount && (error == KErrNone); ++i)

			{

			error = aPhoneBookEntry.AddAdditionalNumber(aPhoneBookStoreEntry.iAnr->MdcaPoint(i));

			}

		}

	return error;

	}

void CPhonebookDispatcher::FillCtsyPhoneBookStoreL(const TDesC8& aPhonebookEntries, 

													CArrayPtrSeg<CPhoneBookStoreEntry>& aCtsyPhoneBook)

/**

 * Fills the CTSY Store from the phonebook entries contained in a descriptor TLV.

 *  

 * 

 * @param aPhonebookEntries The TLV entries.

 * @param aCtsyPhoneBook The CTSY phonebook to fill.

 */

	{

	//we need to create a copy of aPhoneBookEntry as the CPhoneBookBuffer can only be set with a TDes

	RBuf8 readBuffer;

	CleanupClosePushL(readBuffer);

	readBuffer.CreateL(aPhonebookEntries);

	CPhoneBookBuffer* phoneBookBuffer = new (ELeave) CPhoneBookBuffer();

	CleanupStack::PushL(phoneBookBuffer);

	phoneBookBuffer->Set(&readBuffer);

	phoneBookBuffer->StartRead();

	CPhoneBookEntry* phoneBookEntry = CPhoneBookEntry::NewLC();

	TBool entryRead = EFalse;

	while(phoneBookBuffer->RemainingReadLength() > 0)

		{

		User::LeaveIfError(phoneBookEntry->InternalizeFromTlvEntry(*phoneBookBuffer,entryRead));

		CPhoneBookStoreEntry* phoneBookStoreEntry = CreatePhoneBookStoreEntryLC(*phoneBookEntry);

		aCtsyPhoneBook.AppendL(phoneBookStoreEntry); //takes ownership

		CleanupStack::Pop(phoneBookStoreEntry);

		phoneBookEntry->Reset();

		entryRead = ETrue;

		}

	CleanupStack::PopAndDestroy(phoneBookEntry);

	CleanupStack::PopAndDestroy(phoneBookBuffer);

	CleanupStack::PopAndDestroy(&readBuffer);

	}

const TDesC& CPhonebookDispatcher::PhonebookName(DispatcherPhonebook::TPhonebook aPhonebookType) const

/**

 * Converts phonebook enum type to a phonebook name descriptor.

 * 

 * @param The phonebook type.

 * @return A TDeC reference containing the associated ETel name for the phonebook.

 */

	{

	switch(aPhonebookType)

		{

		case DispatcherPhonebook::EIccAdn:

			return KETelIccAdnPhoneBook;

		case DispatcherPhonebook::EIccBdn:

			return KETelIccBdnPhoneBook;

		case DispatcherPhonebook::EIccSdn:

			return KETelIccSdnPhoneBook;

		case DispatcherPhonebook::EIccFdn:

			return KETelIccFdnPhoneBook;

		case DispatcherPhonebook::EIccVmb:

			return KETelIccVoiceMailBox;

		case DispatcherPhonebook::EIccMbdn:

			return KETelIccMbdnPhoneBook;

		case DispatcherPhonebook::EUnknown:

		default:

			return KNullDesC;

		}

	}

DispatcherPhonebook::TPhonebook CPhonebookDispatcher::Phonebook(const TDesC& aPhonebookName) const

/**

 * Converts a phonebook name descriptor into an enum type.

 * 

 * @param aPhonebookName The phonebook name.

 * @return The phonebook enum type.

 */

	{

	DispatcherPhonebook::TPhonebook phonebook = DispatcherPhonebook::EUnknown;

	if(aPhonebookName == KETelIccFdnPhoneBook)

		{

		phonebook = DispatcherPhonebook::EIccFdn;

		}

	else if(aPhonebookName == KETelIccAdnPhoneBook)

		{

		phonebook = DispatcherPhonebook::EIccAdn;

		}

	else if(aPhonebookName == KETelIccSdnPhoneBook)

		{

		phonebook = DispatcherPhonebook::EIccSdn;

		}

	else if(aPhonebookName == KETelIccBdnPhoneBook)

		{

		phonebook = DispatcherPhonebook::EIccBdn;

		}

	else if(aPhonebookName == KETelIccVoiceMailBox)

		{

		phonebook = DispatcherPhonebook::EIccVmb;

		}

	else if(aPhonebookName == KETelIccMbdnPhoneBook)

		{

		phonebook = DispatcherPhonebook::EIccMbdn;

		}

	return phonebook;

	}

void CPhonebookDispatcher::PhonebookStoreToStorageInfo(const DispatcherPhonebook::TPhonebookStoreInfoV1& aPhonebookStoreInfo, CStorageInfoData& aStorageInfoData) const

/**

 * Write data into a CTSY CStorageInfoData structure from a TPhonebookStoreInfoV1 dispatcher structure.

 * 

 * @param aPhonebookStoreData The dispatcher structure to read from.

 * @param aStorageInfoData The CTSY structure to write to.

 */

{

	aStorageInfoData.iADNNumOfEntries 			= aPhonebookStoreInfo.iAdnTotalEntries;

	aStorageInfoData.iADNTextLengthMax 			= aPhonebookStoreInfo.iAdnMaximumTextLength;

	aStorageInfoData.iADNNumberLengthMax 		= aPhonebookStoreInfo.iAdnMaximumNumberLength;

	aStorageInfoData.iSNENumOfEntriesPerEntry 	= aPhonebookStoreInfo.iSecondNameMaximumFieldsPerEntry;

	aStorageInfoData.iSNETextLengthMax			= aPhonebookStoreInfo.iSecondNameMaximumLength;

	aStorageInfoData.iEmailNumOfEntriesPerEntry = aPhonebookStoreInfo.iEmailMaximumFieldsPerEntry;

	aStorageInfoData.iEmailTextLengthMax 		= aPhonebookStoreInfo.iEmailMaximumLength;

	aStorageInfoData.iFDNNumOfEntries 			= aPhonebookStoreInfo.iFdnTotalEntries;

	aStorageInfoData.iFDNTextLengthMax 			= aPhonebookStoreInfo.iFdnMaximumTextLength;

	aStorageInfoData.iFDNNumberLengthMax 		= aPhonebookStoreInfo.iFdnMaximumNumberLength;

	aStorageInfoData.iSDNNumOfEntries			= aPhonebookStoreInfo.iSdnTotalEntries;

	aStorageInfoData.iSDNTextLengthMax 			= aPhonebookStoreInfo.iSdnMaximumTextLength;

	aStorageInfoData.iSDNNumberLengthMax 		= aPhonebookStoreInfo.iSdnMaximumNumberLength;

	aStorageInfoData.iVMBXNumOfEntries 			= aPhonebookStoreInfo.iVmbTotalEntries;

	aStorageInfoData.iVMBXTextLengthMax 		= aPhonebookStoreInfo.iVmbMaximumTextLength;

	aStorageInfoData.iVMBXNumberLengthMax 		= aPhonebookStoreInfo.iVmbMaximumNumberLength;

	aStorageInfoData.iVMBXCaps 					= aPhonebookStoreInfo.iVmbCapabilities;

	aStorageInfoData.iANRNumOfEntriesPerEntry 	= aPhonebookStoreInfo.iAdditionalNumberMaximumFieldsPerEntry;

	aStorageInfoData.iANRNumLengthMax 			= aPhonebookStoreInfo.iAdditionalNumberMaximumLength;

	aStorageInfoData.iMBDNNumOfEntries 			= aPhonebookStoreInfo.iMbdnTotalEntries;

	aStorageInfoData.iMBDNTextLengthMax 		= aPhonebookStoreInfo.iMbdnMaximumTextLength;

	aStorageInfoData.iMBDNNumberLengthMax 		= aPhonebookStoreInfo.iMbdnMaximumNumberLength;

	aStorageInfoData.iMBDNCaps 					= aPhonebookStoreInfo.iMbdnCapabilities;

	}

void CPhonebookDispatcher::FillSmsStoreListL(const DispatcherPhonebook::TSmsData& aSmsData, TInt aIndex, CArrayPtrFlat< TSmsMsg >& aSmsListArray)

/*

 * Append a TSmsMsg to a sms array.

 * 

 * @param aSmsData A entry of TSmSData where the information will be extracted from to form a TSmsMsg entry.

 * @param aIndex The index of the entry.