telephonyserverplugins/ctsydispatchlayer/src/cphonebookdispatcher.cpp
changeset 0 3553901f7fa8
child 18 17af172ffa5f
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/src/cphonebookdispatcher.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1520 @@
+// 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.
+ * @param aSmsListArray The array where the TSmsMsg entry will be append to.
+ */
+	{
+	TSmsMsg* smsMsg = new (ELeave) TSmsMsg();
+	CleanupStack::PushL(smsMsg);
+	
+	smsMsg->iSmsMsg.Copy(aSmsData.iSmsMsg); 
+	smsMsg->iServiceCentre.Copy(aSmsData.iServiceCentre); 
+	smsMsg->iMobileScTON   = aSmsData.iMobileScTON;  
+	smsMsg->iMobileScNPI   = aSmsData.iMobileScNPI;
+	smsMsg->iMessageStatus = aSmsData.iMessageStatus;
+	smsMsg->iLocation = aIndex;
+	aSmsListArray.AppendL(smsMsg, 1); // aSmsListArray has taken the ownership of the object
+	
+	CleanupStack::Pop(smsMsg);
+
+	}
+
+void CPhonebookDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)
+/**
+ * Set the dispatcher holder.  
+ * 
+ * @param aDispatcherHolder Reference to dispatcher holder.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	iDispatcherHolder = &aDispatcherHolder;
+	} // CPhonebookDispatcher::SetDispatcherHolder
+
+TInt CPhonebookDispatcher::DispatchStoreReadEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreReadIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreReadEntry)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+		
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		
+		RMobilePhoneBookStore::TPBIndexAndNumEntries* indexAndEntries = NULL;
+		
+		phoneBookDataPackage.UnPackData(indexAndEntries);
+		
+		__ASSERT_DEBUG(indexAndEntries, CtsyDispatcherPanic(EInvalidNullPtr));
+		
+		const DispatcherPhonebook::TPhonebook phonebookType = Phonebook(phonebookName);
+		__ASSERT_DEBUG(phonebookType != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+
+		
+		ret = iLtsyDispatchPhonebookStoreReadEntry->HandleStoreReadEntryReqL(phonebookType,indexAndEntries->iIndex,indexAndEntries->iNumSlots);
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreReadEntryL
+
+TInt CPhonebookDispatcher::DispatchStoreDeleteEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreDeleteIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+	
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreDeleteEntry)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+		
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		TInt deleteEntryIndex;
+		phoneBookDataPackage.UnPackData(deleteEntryIndex);
+			
+		ret = iLtsyDispatchPhonebookStoreDeleteEntry->HandleStoreDeleteEntryReqL(Phonebook(phonebookName),deleteEntryIndex);
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreDeleteEntryL
+
+TInt CPhonebookDispatcher::DispatchStoreCacheL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreCacheIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	if (iLtsyDispatchPhonebookStoreCache)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+		
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		const DispatcherPhonebook::TPhonebook phonebookType = Phonebook(phonebookName);
+		__ASSERT_DEBUG(phonebookType != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+		// Call Handle... method in Licensee LTSY
+		ret = iLtsyDispatchPhonebookStoreCache->HandleStoreCacheReqL(Phonebook(phonebookName));
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreCacheL
+
+TInt CPhonebookDispatcher::DispatchStoreGetInfoL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreGetInfoIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreGetPhonebookInfo)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+
+		TName phonebookName;
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		ret = iLtsyDispatchPhonebookStoreGetPhonebookInfo->HandleStoreGetPhonebookInfoReqL(Phonebook(phonebookName));
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreGetInfoL
+
+TInt CPhonebookDispatcher::DispatchStoreInitialiseL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreInitIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreInitialise)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+
+		__ASSERT_DEBUG(iInitialisePhonebook == DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+
+		TName phonebookName;
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		
+		iInitialisePhonebook = Phonebook(phonebookName);
+		
+		__ASSERT_DEBUG(iInitialisePhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		ret = iLtsyDispatchPhonebookStoreInitialise->HandleStoreInitialiseReqL();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreInitialiseL
+
+TInt CPhonebookDispatcher::DispatchStoreDeleteAllL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreDeleteAllIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+	
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreDeleteAll)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		ret = iLtsyDispatchPhonebookStoreDeleteAll->HandleStoreDeleteAllReqL(Phonebook(phonebookName));
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreDeleteAllL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreReadAllL()
+/**
+ * Pass request for EMobilePhoneStoreReadAllPhase1 on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookSmsStoreReadAll)
+		{
+		ret = iLtsyDispatchPhonebookSmsStoreReadAll->HandleSmsStoreReadAllReqL();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreReadAllL
+
+TInt CPhonebookDispatcher::DispatchStoreWriteEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreWriteIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreWriteEntry)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+
+		TInt index;
+		CPhoneBookStoreEntry* ctsyPhonebookEntry = NULL;
+		
+		phoneBookDataPackage.UnPackData(index,ctsyPhonebookEntry);
+		__ASSERT_DEBUG(ctsyPhonebookEntry, CtsyDispatcherPanic(EInvalidNullPtr));
+		
+		//this will be used to convert the CPhoneBookStoreEntry to a TDesC8 containing a TLV
+		CPhoneBookEntry* dispatchPhoneBookEntry = CPhoneBookEntry::NewLC();
+		
+		//convert CPhoneBookStoreEntry to a CPhoneBookEntry
+		User::LeaveIfError(FillPhoneBookEntry(*ctsyPhonebookEntry,*dispatchPhoneBookEntry));
+		ctsyPhonebookEntry = NULL; //don't need this anymore (CTSY owned)
+		dispatchPhoneBookEntry->SetIndex(index);
+		
+		//the buffer for the TLV
+		RBuf8 tlvEntry;
+		CleanupClosePushL(tlvEntry);
+		tlvEntry.CreateL(dispatchPhoneBookEntry->TlvLength());
+		
+		CPhoneBookBuffer* phoneBookBuffer = new (ELeave) CPhoneBookBuffer();
+		CleanupStack::PushL(phoneBookBuffer);
+		phoneBookBuffer->Set(&tlvEntry);
+		//create the TLV
+		User::LeaveIfError(dispatchPhoneBookEntry->ExternalizeToTlvEntry(*phoneBookBuffer));
+
+		CleanupStack::PopAndDestroy(phoneBookBuffer);
+				
+		ret = iLtsyDispatchPhonebookStoreWriteEntry->HandleStoreWriteEntryReqL(Phonebook(phonebookName),tlvEntry);
+		
+		CleanupStack::PopAndDestroy(&tlvEntry);
+		CleanupStack::PopAndDestroy(dispatchPhoneBookEntry);
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreWriteEntryL
+
+TInt CPhonebookDispatcher::DispatchGetPhoneStoreInfoL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneGetPhoneStoreInfo
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookGetPhoneStoreInfo)
+		{
+		//The CTSY treats it as a RMobilePhone::TMobileName but really ETel sends it as a TName
+		RMobilePhone::TMobileName* storeNamePtr = NULL; 
+		aDataPackage->UnPackData(&storeNamePtr);
+		__ASSERT_DEBUG(storeNamePtr, CtsyDispatcherPanic(EInvalidNullPtr));
+
+		ret = iLtsyDispatchPhonebookGetPhoneStoreInfo->HandleGetPhoneStoreInfoReqL(*storeNamePtr);
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchGetPhoneStoreInfoL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreDeleteEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneStoreDelete
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Unpack data for this request inside the if statement if required, 
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+
+	TInt index;
+	aDataPackage->UnPackData(index);
+	if (iLtsyDispatchPhonebookSmsStoreDeleteEntry)
+		{
+		ret = iLtsyDispatchPhonebookSmsStoreDeleteEntry->HandleSmsStoreDeleteEntryReqL(index);
+		}
+		
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreDeleteEntryL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreDeleteAllL()
+/**
+ * Pass request for EMobilePhoneStoreDeleteAll on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookSmsStoreDeleteAll)
+		{
+		ret = iLtsyDispatchPhonebookSmsStoreDeleteAll->HandleSmsStoreDeleteAllReqL();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreDeleteAllL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreGetInfoL()
+/**
+ * Pass request for EMobilePhoneStoreGetInfo on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Call handle method for EMobilePhoneStoreGetInfo in Licensee LTSY
+	if (iLtsyDispatchPhonebookSmsStoreGetInfo)
+		{
+		ret = iLtsyDispatchPhonebookSmsStoreGetInfo->HandleSmsStoreGetInfoReqL();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreGetInfoL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreReadEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneStoreRead
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Unpack data for this request inside the if statement if required, 
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	TInt index;
+	aDataPackage->UnPackData(index);
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookSmsStoreReadEntry)
+		{
+		ret = iLtsyDispatchPhonebookSmsStoreReadEntry->HandleSmsStoreReadEntryReqL(index);
+		}
+		
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreReadEntryL
+
+TInt CPhonebookDispatcher::DispatchSmsStoreWriteEntryL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneStoreWrite
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	 __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+ 
+	TDesC8** data = NULL;
+	TInt* index = NULL;
+	
+	aDataPackage->UnPackData(&data,&index);
+
+	if(!data || !index)
+		{
+		ret = KErrCorrupt;
+		}
+	else
+		{
+		RMobileSmsStore::TMobileGsmSmsEntryV1& mobileGsmSmsEntry = (static_cast<RMobileSmsStore::TMobileGsmSmsEntryV1Pckg&>(**data))();
+		
+		//the CTSY packs index which is also set in the Gsm Sms Entry, this index is not passed though the interface
+		//as a client can examine it from the MobileGsmSmsEntry, we assert here in case the CTSY sets one but not
+		//the other
+		__ASSERT_DEBUG(*index == mobileGsmSmsEntry.iIndex,CtsyDispatcherPanic(ESlotIndexesDontMatch));
+		if (*index != mobileGsmSmsEntry.iIndex)
+			{
+			//for urel build
+			ret = KErrArgument;
+			}
+		// Call Handle... method in Licensee LTSY
+		else if (iLtsyDispatchPhonebookSmsStoreWriteEntry)
+			{
+			ret = iLtsyDispatchPhonebookSmsStoreWriteEntry->HandleSmsStoreWriteEntryReqL(mobileGsmSmsEntry);
+			}
+		}
+	
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchSmsStoreWriteEntryL
+
+TInt CPhonebookDispatcher::DispatchStoreCacheCancelL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMmTsyPhoneBookStoreCacheCancelIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchPhonebookStoreCacheCancel)
+		{
+		const CPhoneBookDataPackage& phoneBookDataPackage = *static_cast<const CPhoneBookDataPackage*>(aDataPackage);
+
+		TName phonebookName(KNullDesC);
+		phoneBookDataPackage.GetPhoneBookName(phonebookName);
+		__ASSERT_DEBUG(phonebookName != KNullDesC, CtsyDispatcherPanic(EInvalidParameter));
+		__ASSERT_DEBUG(Phonebook(phonebookName) != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+		
+		ret = iLtsyDispatchPhonebookStoreCacheCancel->HandleStoreCacheCancelReqL(Phonebook(phonebookName));
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CPhonebookDispatcher::DispatchStoreCacheCancelL
+
+
+//
+// Callback handlers follow
+//
+
+
+
+void CPhonebookDispatcher::CallbackStoreResetCache(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreResetCacheInd()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook to reset the cache for.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d,aPhonebook=%d"), aError, aPhonebook);
+
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreResetCacheIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreResetCache
+
+void CPhonebookDispatcher::CallbackStoreSetFdnPhonebookInfoInd(TInt aError, TInt aTotalEntries, TInt aMaxTextLength, TInt aMaxNumberLength)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreSetFdnPhonebookInfoInd()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aTotalEntries The total number of entries in the Fdn phonebook.
+ * @param aMaxTextLength The maximum text length in the Fdn phonebook.
+ * @param aMaxNumberLength The maximum number length in the Fdn phonebook.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d,aTotalEntries=%d,aMaxTextLength=%d,aMaxNumberLength=%d"), 
+							aError,aTotalEntries,aMaxTextLength,aMaxNumberLength);
+
+	TName phoneBookName(KETelIccFdnPhoneBook);
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(phoneBookName);
+	
+	TPBFdnInfo pbFdnInfo;
+	pbFdnInfo.iFDNNumOfEntries 		= aTotalEntries;
+	pbFdnInfo.iFDNNumberLengthMax 	= aMaxNumberLength;
+	pbFdnInfo.iFDNTextLengthMax 	= aMaxTextLength;
+
+	phoneBookDataPackage.PackData(&pbFdnInfo);
+
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreFdnInfoIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreSetFdnPhonebookInfoInd
+
+void CPhonebookDispatcher::CallbackStoreReadEntry(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aPhonebookEntries)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreReadEntryComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook of which the read request was made and which the enties are for.
+ * @param aPhonebookEntries The read entries from the phonebook encoded in a TLV, this can either be encoded directly 
+ * 	via a CPhoneBookBuffer() or via the CPhoneBookEntry::ExternalizeToTlvEntry() utility.
+ *
+ * @see RMobilePhoneBookStore::Read()
+ * @see CPhoneBookBuffer()
+ * @see CPhoneBookEntry::ExternalizeToTlvEntry()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d,aPhonebook=%d"), aError, aPhonebook);
+	
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));	
+	
+	if (iPhonebookReadPtrs[aPhonebook] != NULL)
+		{
+		iPhonebookReadPtrs[aPhonebook] = NULL;
+		}
+	
+	if((aError == KErrNone) && (aPhonebook != DispatcherPhonebook::EUnknown))
+		{
+		//fill the CTSY pointer		
+		CArrayPtrSeg<CPhoneBookStoreEntry>* readEntries = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>(1);
+		iPhonebookReadPtrs[aPhonebook] = readEntries;
+		
+		TRAP(aError,FillCtsyPhoneBookStoreL(aPhonebookEntries,*(iPhonebookReadPtrs[aPhonebook])));
+		}
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	phoneBookDataPackage.PackData(&(iPhonebookReadPtrs[aPhonebook]));
+	
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreReadIPC, &phoneBookDataPackage, aError);
+		
+	} // CPhonebookDispatcher::CallbackStoreReadEntry
+
+void CPhonebookDispatcher::CallbackStoreDeleteEntry(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aMaxNumberLength)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteEntryComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook of which the delete request was made.
+ * @param aMaxNumberLength The new maximum number length possible in the phonebook, this field is
+ * only relevant to Fdn, Adn and Vmb phonebooks.
+ *
+ * @see RMobilePhoneBookStore::Delete()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aPhonebook=%d, aMaxNumberLength=%d"), aError, aPhonebook, aMaxNumberLength);
+
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	
+	TPBEntryInfo pbEntryInfo;
+	pbEntryInfo.iLocation = 0; //not used the CTSY
+	pbEntryInfo.iMaxNumLength = aMaxNumberLength;
+	
+	phoneBookDataPackage.PackData(&pbEntryInfo);
+	
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreDeleteIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreDeleteEntry
+
+void CPhonebookDispatcher::CallbackStoreCache(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aPhonebookEntries)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreCacheComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook of which the cache entries are for (and the request was made from).
+ * @param aPhonebookEntries All entries from the phonebook encoded in a TLV, this can either be encoded directly 
+ * 	via a CPhoneBookBuffer() or via the CPhoneBookEntry::ExternalizeToTlvEntry() utility.
+ *
+ * @see CPhoneBookBuffer()
+ * @see CPhoneBookEntry::ExternalizeToTlvEntry()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d,aPhonebook=%d"), aError, aPhonebook);
+	
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	if (iPhonebookCachePtrs[aPhonebook] != NULL)
+		{
+		iPhonebookCachePtrs[aPhonebook] = NULL;
+		}
+	
+	if((aError == KErrNone) && (aPhonebook != DispatcherPhonebook::EUnknown)/* && (iPhonebookCachePtrs[aPhonebook])*/)
+		{
+		CArrayPtrSeg<CPhoneBookStoreEntry>* readEntries = new(ELeave) CArrayPtrSeg<CPhoneBookStoreEntry>(1);
+		iPhonebookCachePtrs[aPhonebook] = readEntries;
+			
+		TRAP(aError,FillCtsyPhoneBookStoreL(aPhonebookEntries, *(iPhonebookCachePtrs[aPhonebook])));
+		
+		if(aError)
+			{
+			iPhonebookCachePtrs[aPhonebook]->ResetAndDestroy();
+			}
+		}
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	phoneBookDataPackage.PackData(&(iPhonebookCachePtrs[aPhonebook]));
+
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreCacheIPC, &phoneBookDataPackage, aError);
+	} // CPhonebookDispatcher::CallbackStoreCache
+
+void CPhonebookDispatcher::CallbackStoreGetPhonebookInfo(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aUsedEntries)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreGetPhonebookInfoComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook name of which the phonebook information is for.
+ * @param aUsedEntries The number of used entries in the phonebook.
+ *
+ * @see RMobilePhoneBookStore::GetInfo()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aPhonebook=%d, aUsedEntries=%d"), aError, aPhonebook, aUsedEntries);
+
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	
+	phoneBookDataPackage.PackData(&aUsedEntries);
+
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreGetInfoIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreGetInfo
+
+void CPhonebookDispatcher::CallbackStoreInitialise(TInt aError, const DispatcherPhonebook::TPhonebookStoreInfoV1& aPhonebookStoreInfo)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreInitialiseComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebookStoreInfo The information relating to the whole phonebook store.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	__ASSERT_DEBUG(iInitialisePhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(iInitialisePhonebook));
+	iInitialisePhonebook = DispatcherPhonebook::EUnknown;
+		
+	//CTSY C-Type class really a T-Type class so on the stack
+	CStorageInfoData storageInfoData;
+	
+	//convert the TPhonebookStoreInfoV1 to the CTSY CStorageInfoData
+	PhonebookStoreToStorageInfo(aPhonebookStoreInfo,storageInfoData);
+	
+	phoneBookDataPackage.PackData(&storageInfoData);
+	
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreInitIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreInitialise
+
+void CPhonebookDispatcher::CallbackStoreDeleteAll(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TInt aMaxNumberLength)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteAllComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhonebook The phonebook name for which the delete all request was made.
+ * @param aMaxNumberLength The new maximum number length possible in the phonebook, this field is
+ * only relevant to Fdn, Adn and Vmb phonebooks.
+ *
+ * @see RMobilePhoneBookStore::DeleteAll()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aPhonebook=%d, aMaxNumberLength=%d"), aError, aPhonebook, aMaxNumberLength);
+
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	
+	TPBEntryInfo pbEntryInfo;
+	pbEntryInfo.iLocation = 0; //not used in the CTSY
+	pbEntryInfo.iMaxNumLength = aMaxNumberLength;
+	
+	phoneBookDataPackage.PackData(&pbEntryInfo);
+	
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreDeleteAllIPC, &phoneBookDataPackage, aError);
+	} // CPhonebookDispatcher::CallbackStoreDeleteAll
+
+void CPhonebookDispatcher::CallbackSmsStoreReadAll(TInt aError, const DispatcherPhonebook::TSmsData& aSmsData, TInt aIndex, TBool aMoreToCome, TBool aReceivedClass2ToBeResent)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadAllComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aSmsData SMS data. 
+ * @param aIndex index of the SMS entry. 
+ * @param aMoreToCome ETrue if there will be other SMS entries, EFalse otherwise.   
+ * @param aReceivedClass2ToBeResent ETrue if received class is to be resent, else EFalse.
+ * 
+ * @see CRetrieveMobilePhoneSmsList::Start()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aIndex=%d"), aError, aIndex);
+	TInt errorCode = aError;
+
+	if (errorCode == KErrNone)
+		{
+		TRAP(errorCode, FillSmsStoreListL(aSmsData, aIndex, *iSmsListArray));
+		}
+
+	if (!aMoreToCome || errorCode != KErrNone)
+		{
+		CMmDataPackage dataPackage;
+		dataPackage.PackData(&iSmsListArray, &aReceivedClass2ToBeResent);
+
+		iMessageManagerCallback.Complete(EMobilePhoneStoreReadAllPhase1, &dataPackage, aError);
+		iSmsListArray->ResetAndDestroy();
+		}
+	
+	} // CPhonebookDispatcher::CallbackSmsStoreReadAll
+
+void CPhonebookDispatcher::CallbackStoreWriteEntry(TInt aError, DispatcherPhonebook::TPhonebook aPhonebook, TUint16 aIndex, TInt aMaxNumberLength)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookStoreWriteEntryComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * KErrGsmSimServSneFull, KErrGsmSimServAnrFull, or KErrGsmSimServEmailFull indicates one of the
+ * services is full and the field of the entry (e.g. Email) could not be written. 
+ * In the cache case the field (e.g. Email) is not written to the cache but the other
+ * fields are written, the request is then completed with the error code.  In the non-cache case
+ * the request is completed with the error code.
+ * @param aPhonebook The phonebook name for which the write request was made.
+ * @param aIndex The index to which the entry was written in the phonebook.
+ * @param aMaxNumberLength The new maximum number length possible in the phonebook, this field is
+ * only relevant to Fdn, Adn and Vmb phonebooks.
+ *
+ * @see RMobilePhoneBookStore::Write() 
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d,aPhonebook=%d,aIndex=%d,aMaxNumberLength=%d"), aError, aPhonebook, aIndex, aMaxNumberLength);
+
+	__ASSERT_DEBUG(aPhonebook != DispatcherPhonebook::EUnknown, CtsyDispatcherPanic(EInvalidParameter));
+	
+	CPhoneBookDataPackage phoneBookDataPackage;
+	phoneBookDataPackage.SetPhoneBookName(PhonebookName(aPhonebook));
+	
+	TPBEntryInfo pbEntryInfo;
+	pbEntryInfo.iLocation 		= aIndex;
+	pbEntryInfo.iMaxNumLength 	= aMaxNumberLength;
+	
+	phoneBookDataPackage.PackData(&pbEntryInfo);
+	
+	iMessageManagerCallback.Complete(EMmTsyPhoneBookStoreWriteIPC, &phoneBookDataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackStoreWriteEntry
+
+void CPhonebookDispatcher::CallbackGetPhoneStoreInfo(TInt aError, const RMobilePhoneStore::TMobilePhoneStoreInfoV1& aPhoneStoreInfo)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookGetPhoneStoreInfoComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aPhoneStoreInfo The phone store information.
+ *
+ * @see RMobilePhone::GetPhoneStoreInfo()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&const_cast<RMobilePhoneStore::TMobilePhoneStoreInfoV1&>(aPhoneStoreInfo));
+	
+	iMessageManagerCallback.Complete(EMobilePhoneGetPhoneStoreInfo, &dataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackGetPhoneStoreInfo
+
+void CPhonebookDispatcher::CallbackSmsStoreDeleteEntry(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteEntryComp()
+ *
+ * @param aError The error code to be returned.
+ * 
+ * @see RMobileSmsStore::Delete()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(EMobilePhoneStoreDelete, aError);
+	
+	} // CPhonebookDispatcher::CallbackSmsStoreDeleteEntry
+
+void CPhonebookDispatcher::CallbackSmsStoreDeleteAll(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteAllComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ *
+ * @see RMobileSmsStore::DeleteAll()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+	iMessageManagerCallback.Complete(EMobilePhoneStoreDeleteAll, aError);
+	
+	} // CPhonebookDispatcher::CallbackSmsStoreDeleteAll
+
+void CPhonebookDispatcher::CallbackSmsStoreGetInfo(TInt aError, TInt aTotalEntries, TInt aUsedEntries)				
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreGetInfoComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aTotalEntries total number of entries in the SMS storage.
+ * @param aUsedEntries total number of used entries in the SMS storage.
+ *
+ * @see RMobileSmsStore::GetInfo()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aTotalEntries=%d, aUsedEntries=%d"), aError, aTotalEntries, aUsedEntries);
+	__ASSERT_DEBUG(aTotalEntries <= KMaxTotalEntries, CtsyDispatcherPanic(EInvalidParameter));
+	
+	// Pack the data to return to the Common TSY			
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aTotalEntries, &aUsedEntries);
+	
+	if(aTotalEntries <= KMaxTotalEntries)
+		{
+		iMessageManagerCallback.Complete(EMobilePhoneStoreGetInfo, &dataPackage, aError);		
+		}
+	else
+		{
+		iMessageManagerCallback.Complete(EMobilePhoneStoreGetInfo, &dataPackage, KErrCorrupt);
+		}
+	
+	} // CPhonebookDispatcher::CallbackSmsStoreGetInfo
+
+void CPhonebookDispatcher::CallbackSmsStoreReadEntry(TInt aError, const DispatcherPhonebook::TSmsData& aSmsData)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadEntryComp()
+ *
+ * @param aError KErrNone on success, or another error code indicating the error otherwise.
+ * @param aSmsData SMS data. 
+ *
+ * @see RMobileSmsStore::Read()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	// Pack the data to return to the Common TSY
+	
+	TSmsMsg smsMsg;
+	smsMsg.iSmsMsg.Copy(aSmsData.iSmsMsg); 
+	smsMsg.iServiceCentre.Copy(aSmsData.iServiceCentre); 
+	smsMsg.iMobileScTON   = aSmsData.iMobileScTON;  
+	smsMsg.iMobileScNPI   = aSmsData.iMobileScNPI;
+	smsMsg.iMessageStatus = aSmsData.iMessageStatus;
+		
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(const_cast<TSmsMsg*>(&smsMsg));
+	iMessageManagerCallback.Complete(EMobilePhoneStoreRead, &dataPackage, aError);
+	
+	} // CPhonebookDispatcher::CallbackSmsStoreReadEntry
+
+void CPhonebookDispatcher::CallbackSmsStoreWriteEntry(TInt aError, TInt aLocation, TBool aReceivedClass2ToBeResent)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreWriteEntryComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aLocation location of the entry.
+ * @param aReceivedClass2ToBeResent ETrue if received class is to be resent, else EFalse.  
+ *
+ * @see RMobileSmsStore::Write()
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aLocation=%d, aReceivedClass2ToBeResent=%d"), aError, aLocation, aReceivedClass2ToBeResent);
+	__ASSERT_DEBUG(aLocation <= KMaxTotalEntries, CtsyDispatcherPanic(EInvalidParameter));
+	
+	// Pack the data to return to the Common TSY
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aLocation, &aReceivedClass2ToBeResent);
+	
+	if(aLocation <= KMaxTotalEntries)
+		{
+		iMessageManagerCallback.Complete(EMobilePhoneStoreWrite, &dataPackage, aError);
+		}
+	else
+		{
+		iMessageManagerCallback.Complete(EMobilePhoneStoreWrite, &dataPackage, KErrCorrupt);
+		}
+		
+	} // CPhonebookDispatcher::CallbackSmsStoreWriteEntry
+
+void CPhonebookDispatcher::CallbackSync(CRequestQueueOneShot::TIpcDataPackage& aIpcDataPackage)
+/**
+ * Part of the MDispatcherCallback interface. Used to complete requests handled
+ * synchronously by the Licensee LTSY asynchronously back to the Common TSY.
+ *  
+ * @param aIpcDataPackage Package encapsulating the request.
+ * 
+ * @see MDispatcherCallback::CallbackSync
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	switch (aIpcDataPackage.iIpc)
+		{
+	
+	default:
+		LOG(_L8("WARNING: CPhonebookDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc);
+		__ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc));
+		break;		
+		} // switch (aIpcDataPackage.iIpc)
+	
+	} // CPhonebookDispatcher::CallbackSync
+
+
+