1 // Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // CLtsyPhonebookHandler

    15 

    16 #include <ctsy/ltsy/cctsydispatchercallback.h>

    17 #include <mmtsy_ipcdefs.h>

    18 #include <mpbutil.h>

    19 #include <etelmm.h>

    20 

    21 

    22 #include "cltsyphonebookhandler.h"

    23 #include <ctsy/ltsy/ltsylogger.h>

    24 #include "ltsymacros.h"

    25 #include "globalphonemanager.h"

    26 #include "atsmsstoreinfo.h"

    27 #include "atsmsstorewrite.h"

    28 #include "atsmsstoreread.h"

    29 #include "atsmsstoredelete.h"

    30 #include "atsmsstorereadall.h"

    31 #include "atphbkgetphonestoreinfo.h"

    32 #include "atphbkstoreinitialise.h"

    33 #include "atphbkstorewrite.h"

    34 #include "atphbkstoreread.h"

    35 #include "atphbkstorecache.h"

    36 #include "atphbkstoredelete.h"

    37 

    38 

    39 CLtsyPhonebookHandler::CLtsyPhonebookHandler(

    40 	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)

    41     :iCtsyDispatcherCallback(aCtsyDispatcherCallback),iGloblePhone(aGloblePhone)

    42 	{

    43 	}

    44 

    45 	

    46 CLtsyPhonebookHandler::~CLtsyPhonebookHandler()

    47 	{

    48 

    49 	}

    50 

    51 

    52 CLtsyPhonebookHandler* CLtsyPhonebookHandler::NewLC(

    53 	CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)

    54 	{

    55 	TSYLOGENTRYEXIT;

    56 	CLtsyPhonebookHandler* self = new (ELeave) CLtsyPhonebookHandler(aCtsyDispatcherCallback,aGloblePhone);

    57 	CleanupStack::PushL(self);

    58 	self->ConstructL();

    59 	return self;

    60 	}

    61 

    62 

    63 CLtsyPhonebookHandler* CLtsyPhonebookHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback,CGlobalPhonemanager* aGloblePhone)

    64 	{

    65 	TSYLOGENTRYEXIT;

    66 	CLtsyPhonebookHandler* self=

    67 			CLtsyPhonebookHandler::NewLC(aCtsyDispatcherCallback,aGloblePhone);

    68 	CleanupStack::Pop(self);

    69 	return self;

    70 	}

    71 

    72 

    73 void CLtsyPhonebookHandler::ConstructL()

    74 /**

    75  * Second phase constructor.

    76  */

    77 	{

    78 	TSYLOGENTRYEXIT;

    79 	} // CLtsyPhonebookHandler::ConstructL

    80 

    81 TBool CLtsyPhonebookHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

    82 /**

    83  * Returns whether a Dispatch Interface APi is supported or not.

    84  * 

    85  * @param aDispatchApiId Id of Dispatch interface being queried.

    86  * @return indication whether interface is supported or not.

    87  */

    88 	{

    89 

    90 	switch(aDispatchApiId)

    91 		{

    92 		case KLtsyDispatchPhonebookStoreReadEntryApiId: 

    93 			return ETrue;	

    94 		case KLtsyDispatchPhonebookStoreDeleteEntryApiId: 

    95 		 	return ETrue;	

    96 		case KLtsyDispatchPhonebookStoreCacheApiId: 

    97 			return ETrue;	

    98 		case KLtsyDispatchPhonebookStoreCacheCancelApiId: 

    99 			return ETrue;		

   100 //		case KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId: 

   101 //			return ETrue;	

   102 		case KLtsyDispatchPhonebookStoreInitialiseApiId: 

   103 			return ETrue;			

   104 		case KLtsyDispatchPhonebookStoreDeleteAllApiId: 

   105 			return ETrue;	

   106 		case KLtsyDispatchPhonebookStoreWriteEntryApiId: 

   107 			return ETrue;	

   108 		case KLtsyDispatchPhonebookGetPhoneStoreInfoApiId: 

   109 			return ETrue;		

   110 		case KLtsyDispatchPhonebookSmsStoreReadAllApiId: 

   111 			return ETrue;	

   112 		case KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId: 

   113 			return ETrue;	

   114 		case KLtsyDispatchPhonebookSmsStoreDeleteAllApiId: 

   115 			return ETrue;	

   116 		case KLtsyDispatchPhonebookSmsStoreGetInfoApiId: 

   117 			return ETrue;	

   118 		case KLtsyDispatchPhonebookSmsStoreReadEntryApiId: 

   119 			return ETrue;		

   120 		case KLtsyDispatchPhonebookSmsStoreWriteEntryApiId: 

   121 			return ETrue;	

   122 		default:

   123 			return EFalse;

   124 		}

   125 	}

   126 

   127 void CLtsyPhonebookHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup /*aIdGroup*/, TUint32& /*aIndIdBitMask*/)

   128 /**

   129  * Returns the set of callback indicators that are supported.

   130  * 

   131 * @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1.

   132 * @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.

   133  */

   134 	{

   135 

   136 	//Create bitmask with bitset for each indicator ID that is supported. E.g.

   137 	}

   138 

   139 

   140 TInt CLtsyPhonebookHandler::HandleStoreReadEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex, TInt aNumberOfSlots)

   141 /**

   142  * This request is completed by invoking

   143  * CCtsyDispatcherCallback::CallbackPhonebookStoreReadEntryComp()

   144  *

   145  * @param aPhonebook The phonebook to read entries from.

   146  * @param aIndex Specifies the index to start reading from, must be >= 1.

   147  * @param aNumSlots Specifies the number of slots to read, must be >= 1 and <= total number of slots.

   148  * 

   149  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   150  * or another error code to indicate the failure otherwise.

   151  * 

   152  * @see RMobilePhoneBookStore::Read()

   153  */

   154 	{

   155 	TSYLOGENTRYEXIT;

   156 	

   157 	if((aPhonebook != DispatcherPhonebook::EIccAdn)&&

   158 			(aPhonebook != DispatcherPhonebook::EIccAdn))

   159 		{

   160 		return TSYLOGSETEXITERR(KErrNotSupported);

   161 		}

   162 

   163 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   164 	if( KErrNone == ret )

   165 		{

   166 		CAtPhbkStoreRead* atPhbkStoreRead = CAtPhbkStoreRead::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   167 		//Setting Port active

   168 		iGloblePhone->iEventSignalActive = ETrue;

   169 		iGloblePhone->SetActiveRequest(atPhbkStoreRead);

   170 		atPhbkStoreRead->SetPhonebookType(aPhonebook);

   171 		atPhbkStoreRead->SetReadParam(aIndex,aNumberOfSlots);

   172 		atPhbkStoreRead->StartRequest();

   173 	    }

   174 	return TSYLOGSETEXITERR(ret);

   175 	} // CLtsyPhonebookHandler::HandleStoreReadEntryReqL

   176 

   177 

   178 TInt CLtsyPhonebookHandler::HandleStoreDeleteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex)

   179 /**

   180  * This request is completed by invoking

   181  * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteEntryComp()

   182  *

   183  * @param aPhonebook The phonebook to delete an entry from.

   184  * @param aIndex The entry index in the phonebook to delete.

   185  *

   186  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   187  * or another error code to indicate the failure otherwise.

   188  * 

   189  * @see RMobilePhoneBookStore::Delete() 

   190  */

   191 	{

   192 	TSYLOGENTRYEXIT;

   193 	

   194 	if((aPhonebook != DispatcherPhonebook::EIccAdn)&&

   195 			(aPhonebook != DispatcherPhonebook::EIccAdn))

   196 		{

   197 		return TSYLOGSETEXITERR(KErrNotSupported);

   198 		}

   199 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   200 	if( KErrNone == ret )

   201 		{

   202 		CAtPhbkStoreDelete* atPhbkStoreDelete = CAtPhbkStoreDelete::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   203 		//Setting Port active

   204 		iGloblePhone->iEventSignalActive = ETrue;

   205 		iGloblePhone->SetActiveRequest(atPhbkStoreDelete);

   206 		atPhbkStoreDelete->SetPhonebookType(aPhonebook);

   207 		atPhbkStoreDelete->SetDeleteIndex(aIndex);

   208 		atPhbkStoreDelete->StartRequest();

   209 	    }

   210 	return TSYLOGSETEXITERR(ret);

   211 	} // CLtsyPhonebookHandler::HandleStoreDeleteEntryReqL

   212 

   213 

   214 TInt CLtsyPhonebookHandler::HandleStoreCacheReqL(DispatcherPhonebook::TPhonebook aPhonebook)

   215 /**

   216  * This request is completed by invoking

   217  * CCtsyDispatcherCallback::CallbackPhonebookStoreCacheComp()

   218  *

   219  * @param aPhonebook The phonebook to cache.

   220  *

   221  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   222  * or another error code to indicate the failure otherwise.

   223  */

   224 	{

   225 	TSYLOGENTRYEXIT;

   226 	if((aPhonebook != DispatcherPhonebook::EIccAdn)&&

   227 			(aPhonebook != DispatcherPhonebook::EIccAdn))

   228 		{

   229 		return TSYLOGSETEXITERR(KErrNotSupported);

   230 		}

   231 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   232 	if( KErrNone == ret )

   233 		{

   234 		CAtPhbkStoreCache* atPhbkStoreCache = CAtPhbkStoreCache::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   235 		//Setting Port active

   236 		iGloblePhone->iEventSignalActive = ETrue;

   237 		iGloblePhone->SetActiveRequest(atPhbkStoreCache);

   238 		atPhbkStoreCache->SetPhonebookType(aPhonebook);

   239 		atPhbkStoreCache->StartRequest();

   240 	    }

   241 	return TSYLOGSETEXITERR(ret);

   242 	} // CLtsyPhonebookHandler::HandleStoreCacheReqL

   243 

   244 

   245 TInt CLtsyPhonebookHandler::HandleStoreGetPhonebookInfoReqL(DispatcherPhonebook::TPhonebook /*aPhonebook*/)

   246 /**

   247  * This request is completed by invoking

   248  * CCtsyDispatcherCallback::CallbackPhonebookStoreGetPhonebookInfoComp()

   249  *

   250  * @param aPhonebook The phonebook to retrieve the information from.

   251  *

   252  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   253  * or another error code to indicate the failure otherwise.

   254  * 

   255  * @see RMobilePhoneBookStore::GetInfo() 

   256  */

   257 	{

   258 	TSYLOGENTRYEXIT;

   259 

   260 	TInt ret = KErrNotSupported;

   261 

   262 	// TODO: Add implementation here.......

   263 

   264 

   265 

   266 	return TSYLOGSETEXITERR(ret);

   267 	} // CLtsyPhonebookHandler::HandleStoreGetPhonebookInfoReqL

   268 

   269 

   270 TInt CLtsyPhonebookHandler::HandleStoreInitialiseReqL()

   271 /**

   272  * This request is completed by invoking

   273  * CCtsyDispatcherCallback::CallbackPhonebookStoreInitialiseComp()

   274  *

   275  *

   276  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   277  * or another error code to indicate the failure otherwise.

   278  */

   279 	{

   280 	TSYLOGENTRYEXIT;

   281 

   282     TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   283 	if( KErrNone == ret )

   284 		{

   285 		CAtPhbkStoreInitialise* atPhbkStoreInitialise = CAtPhbkStoreInitialise::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   286 		//Setting Port active

   287 		iGloblePhone->iEventSignalActive = ETrue;

   288 		iGloblePhone->SetActiveRequest(atPhbkStoreInitialise);

   289 		atPhbkStoreInitialise->StartRequest();

   290 	    }

   291 	return TSYLOGSETEXITERR(ret);

   292 	} // CLtsyPhonebookHandler::HandleStoreInitialiseReqL

   293 

   294 

   295 TInt CLtsyPhonebookHandler::HandleStoreDeleteAllReqL(DispatcherPhonebook::TPhonebook /*aPhonebook*/)

   296 /**

   297  * This request is completed by invoking

   298  * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteAllComp()

   299  *

   300  * @param aPhonebook The phonebook to delete all entries from.

   301  *

   302  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   303  * or another error code to indicate the failure otherwise.

   304  * 

   305  * @see RMobilePhoneBookStore::DeleteAll() 

   306  */

   307 	{

   308 	TSYLOGENTRYEXIT;

   309 

   310 	TInt ret = KErrNotSupported;

   311 

   312 	// TODO: Add implementation here.......

   313 

   314 

   315 	return TSYLOGSETEXITERR(ret);

   316 	} // CLtsyPhonebookHandler::HandleStoreDeleteAllReqL

   317 

   318 

   319 TInt CLtsyPhonebookHandler::HandleSmsStoreReadAllReqL()

   320 /**

   321  * This request is completed by invoking

   322  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadAllComp().

   323  *

   324  *

   325  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   326  * or another error code to indicate the failure otherwise.

   327  */

   328 	{

   329 	TSYLOGENTRYEXIT;

   330 

   331 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   332 	if( KErrNone == ret )

   333 		{

   334 		CAtSmsStoreReadAll* atSmsStoreReadAll = CAtSmsStoreReadAll::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   335 		//Setting Port active

   336 		iGloblePhone->iEventSignalActive = ETrue;

   337 		iGloblePhone->SetActiveRequest(atSmsStoreReadAll);

   338 		atSmsStoreReadAll->StartRequest();

   339 	    }

   340 	return TSYLOGSETEXITERR(ret);

   341 	} // CLtsyPhonebookHandler::HandleSmsStoreReadAllReqL

   342 

   343 

   344 TInt CLtsyPhonebookHandler::HandleStoreWriteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aEntry)

   345 /**

   346  * This request is completed by invoking

   347  * CCtsyDispatcherCallback::CallbackPhonebookStoreWriteEntryComp()

   348  *

   349  * @param aPhonebook The phonebook to be written to.

   350  * @param aEntry The entry to be written, this is coded as a TLV, this can be decoded either

   351  * directly via a CPhoneBookBuffer() or via the CPhoneBookEntry::InternalizeFromTlvEntry() utility.

   352  *

   353  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   354  * or another error code to indicate the failure otherwise.

   355  * 

   356  * @see RMobilePhoneBookStore::Write()

   357  * @see CPhoneBookBuffer()

   358  * @see CPhoneBookEntry::InternalizeFromTlvEntry()

   359  */

   360 	{

   361 	TSYLOGENTRYEXIT;

   362 	if((aPhonebook != DispatcherPhonebook::EIccAdn)&&

   363 			(aPhonebook != DispatcherPhonebook::EIccAdn))

   364 		{

   365 		return TSYLOGSETEXITERR(KErrNotSupported);

   366 		}

   367 	

   368     TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   369 	if( KErrNone == ret )

   370 		{

   371 		CAtPhbkStoreWrite* atPhbkStoreWrite = CAtPhbkStoreWrite::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   372 		//Setting Port active

   373 		iGloblePhone->iEventSignalActive = ETrue;

   374 		iGloblePhone->SetActiveRequest(atPhbkStoreWrite);

   375 		atPhbkStoreWrite->SetPhonebookType(aPhonebook);

   376 		atPhbkStoreWrite->SetPhonebookEntryL(aEntry);

   377 		atPhbkStoreWrite->StartRequest();

   378 	    }              

   379 	

   380 	return TSYLOGSETEXITERR(ret);

   381 	} // CLtsyPhonebookHandler::HandleStoreWriteEntryReqL

   382 

   383 

   384 TInt CLtsyPhonebookHandler::HandleGetPhoneStoreInfoReqL(const TDesC& aStoreName)

   385 /**

   386  * This request is completed by invoking

   387  * CCtsyDispatcherCallback::CallbackPhonebookGetPhoneStoreInfoComp()

   388  *

   389  * @param aStoreName The store to retrieve the information from.

   390  *

   391  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   392  * or another error code to indicate the failure otherwise.

   393  * 

   394  * @see RMobilePhone::GetPhoneStoreInfo()

   395  */

   396 	{

   397 	TSYLOGENTRYEXIT;

   398 	if((aStoreName.CompareF(KETelIccFdnPhoneBook) != KErrNone)

   399 		&&(aStoreName.CompareF(KETelIccAdnPhoneBook) != KErrNone)

   400 		&&(aStoreName.CompareF(KETelIccSmsStore) != KErrNone))

   401 		{

   402 		return TSYLOGSETEXITERR(KErrNotSupported);

   403 		}

   404 	

   405 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   406 	if( KErrNone == ret )

   407 		{

   408 		CAtPhbkGetPhoneStoreInfo* atPhbkGetPhoneStoreInfo =CAtPhbkGetPhoneStoreInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   409 		//Setting Port active

   410 		iGloblePhone->iEventSignalActive = ETrue;

   411 		iGloblePhone->SetActiveRequest(atPhbkGetPhoneStoreInfo);

   412 		atPhbkGetPhoneStoreInfo->SetPhoneStoreParam(aStoreName);

   413 		atPhbkGetPhoneStoreInfo->StartRequest();

   414 	    }

   415 	

   416 	return TSYLOGSETEXITERR(ret);

   417 	} // CLtsyPhonebookHandler::HandleGetPhoneStoreInfoReqL

   418 

   419 

   420 TInt CLtsyPhonebookHandler::HandleSmsStoreDeleteEntryReqL(TInt aIndex)

   421 /**

   422  * This request is completed by invoking

   423  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteEntryComp().

   424  *

   425  * @param aIndex index of the entry to be deleted from the SMS store.

   426  *

   427  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   428  * or another error code to indicate the failure otherwise.

   429  */

   430 	{

   431 	TSYLOGENTRYEXIT;

   432 	

   433 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   434 	if( KErrNone == ret )

   435 		{

   436 		CAtSmsStoreDelete* atSmsStoreDelete = CAtSmsStoreDelete::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   437 		//Setting Port active

   438 		iGloblePhone->iEventSignalActive = ETrue;

   439 		iGloblePhone->SetActiveRequest(atSmsStoreDelete);

   440 		atSmsStoreDelete->SetDelIndex(aIndex);

   441 		atSmsStoreDelete->StartRequest();

   442 		}

   443 	

   444 	return TSYLOGSETEXITERR(ret);

   445 	} // CLtsyPhonebookHandler::HandleSmsStoreDeleteEntryReqL

   446 

   447 

   448 TInt CLtsyPhonebookHandler::HandleSmsStoreDeleteAllReqL()

   449 /**

   450  * This request is completed by invoking

   451  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteAllComp().

   452  *

   453  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   454  * or another error code to indicate the failure otherwise.

   455  */

   456 	{

   457 	TSYLOGENTRYEXIT;

   458 

   459 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   460 	if( KErrNone == ret )

   461 		{

   462 		CAtSmsStoreDeleteAll* atSmsStoreDeleteAll = CAtSmsStoreDeleteAll::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   463 		//Setting Port active

   464 		iGloblePhone->iEventSignalActive = ETrue;

   465 		iGloblePhone->SetActiveRequest(atSmsStoreDeleteAll);

   466 		atSmsStoreDeleteAll->StartRequest();

   467 		}

   468 

   469 	return TSYLOGSETEXITERR(ret);

   470 	} // CLtsyPhonebookHandler::HandleSmsStoreDeleteAllReqL

   471 

   472 

   473 TInt CLtsyPhonebookHandler::HandleSmsStoreGetInfoReqL()

   474 /**

   475  * This request is completed by invoking

   476  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreGetInfoComp().

   477  *

   478  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   479  * or another error code to indicate the failure otherwise.

   480  */

   481 	{

   482 	TSYLOGENTRYEXIT;

   483 

   484 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   485 	if( KErrNone == ret )

   486 		{

   487 		CAtSmsStoreInfo* atSmsStoreInfo = CAtSmsStoreInfo::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   488 		//Setting Port active

   489 		iGloblePhone->iEventSignalActive = ETrue;

   490 		iGloblePhone->SetActiveRequest(atSmsStoreInfo);

   491 		atSmsStoreInfo->StartRequest();

   492 		}

   493 

   494 	return TSYLOGSETEXITERR(ret);

   495 	} // CLtsyPhonebookHandler::HandleSmsStoreGetInfoReqL

   496 

   497 

   498 TInt CLtsyPhonebookHandler::HandleSmsStoreReadEntryReqL(TInt aIndex)

   499 /**

   500  * This request is completed by invoking

   501  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadEntryComp().

   502  *

   503  * @param aIndex index of the entry to be read.

   504  *

   505  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   506  * or another error code to indicate the failure otherwise.

   507  */

   508 	{

   509 	TSYLOGENTRYEXIT;

   510 

   511 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   512 	if( KErrNone == ret )

   513 		{

   514 		CAtSmsStoreRead* atSmsStoreRead = CAtSmsStoreRead::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   515 		//Setting Port active

   516 		iGloblePhone->iEventSignalActive = ETrue;

   517 		iGloblePhone->SetActiveRequest(atSmsStoreRead);

   518 		atSmsStoreRead->SetMsgIndex(aIndex);

   519 		atSmsStoreRead->StartRequest();

   520 		}

   521 	return TSYLOGSETEXITERR(ret);

   522 	} // CLtsyPhonebookHandler::HandleSmsStoreReadEntryReqL

   523 

   524 

   525 TInt CLtsyPhonebookHandler::HandleSmsStoreWriteEntryReqL(const RMobileSmsStore::TMobileGsmSmsEntryV1& aMobileGsmEntry)

   526 /**

   527  * This request is completed by invoking

   528  * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreWriteEntryComp().

   529  *

   530  * @param aMobileGsmEntry Defines contents of a fixed-size GSM SMS entry to be stored.

   531  *

   532  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   533  * or another error code to indicate the failure otherwise.

   534  */

   535 	{

   536 	TSYLOGENTRYEXIT;

   537 

   538 	TInt ret = iGloblePhone->CheckGlobalPhoneStatus();

   539 	if( KErrNone == ret )

   540 		{

   541 		CAtSmsStoreWrite* atSmsStoreWrite = CAtSmsStoreWrite::NewL(*iGloblePhone,iCtsyDispatcherCallback);

   542 		//Setting Port active

   543 		iGloblePhone->iEventSignalActive = ETrue;

   544 		iGloblePhone->SetActiveRequest(atSmsStoreWrite);

   545 		atSmsStoreWrite->SeGsmSmsEntry(aMobileGsmEntry);

   546 		atSmsStoreWrite->StartRequest();

   547 		}

   548 	return TSYLOGSETEXITERR(ret);

   549 	} // CLtsyPhonebookHandler::HandleSmsStoreWriteEntryReqL

   550 

   551 

   552 TInt CLtsyPhonebookHandler::HandleStoreCacheCancelReqL(DispatcherPhonebook::TPhonebook /*aPhonebook*/)

   553 /**

   554  * This request is completed by invoking

   555  * CCtsyDispatcherCallback::CallbackPhonebookStoreCacheCancel()

   556  *

   557  * @param aPhonebook The phonebook to cancel the pending cache.

   558  *

   559  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   560  * or another error code to indicate the failure otherwise.

   561  */

   562 	{

   563 	TSYLOGENTRYEXIT;

   564 

   565 	TInt ret = KErrNotSupported;

   566 

   567 	

   568 	return TSYLOGSETEXITERR(ret);

   569 	} // CLtsyPhonebookHandler::HandleStoreCacheCancelReqL

   570