1 // Copyright (c) 2008-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 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to Phonebook related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHPHONEBOOKINTERFACE_H_

    28 #define MLTSYDISPATCHPHONEBOOKINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 #include <etelmm.h>

    32 

    33 #include <ctsy/serviceapi/cmmsmsutility.h>

    34 

    35 namespace DispatcherPhonebook

    36 	{

    37 	

    38 	/**

    39 	 * This namespace contains all types relating to the phonebook dispatcher.

    40 	 */

    41 	

    42 	/**

    43 	 * Enum containing all the supported phonebook types

    44 	 */

    45 	enum TPhonebook

    46 		{

    47 		EIccAdn = 0, 	//Abbriviated Dailling Numbers

    48 		EIccBdn,		//Barred Dailling Numbers

    49 		EIccSdn,		//Service Dialling numbers

    50 		EIccFdn,		//Fixed Dialling numbers

    51 		EIccVmb,		//Voice Mail Box

    52 		EIccMbdn,		//Mailbox dialling numbers

    53 		EUnknown

    54 		};

    55 	

    56 	class TPhonebookStoreInfoV1

    57 		{

    58 		

    59 		/**

    60 		 * This structure contains the details required by the CTSY about the various

    61 		 * phonebook stores, it is used in the initialisation procedure.

    62 		 * 

    63 		 * Total Entries 			- The total number of entries the store can contain.

    64 		 * Maximum Text Length 		- The maximum length of a text field in the store.

    65 		 * Maximum Number Length 	- The maximum length of a number in the store.

    66 		 * Capabilities 			- The Bit field of the stores capabilities (RMobilePhoneStore::TMobilePhoneStoreCaps).

    67 		 * Maximum Fields Per Entry - The maximum number of fields in a given entry.

    68 		 */

    69 		

    70 	public:

    71 		

    72 		TPhonebookStoreInfoV1() :

    73 			iAdnTotalEntries(-1),

    74 			iAdnMaximumTextLength(-1),

    75 			iAdnMaximumNumberLength(-1),

    76 			iFdnTotalEntries(-1),

    77 			iFdnMaximumTextLength(-1),

    78 			iFdnMaximumNumberLength(-1),

    79 			iSdnTotalEntries(-1),

    80 			iSdnMaximumTextLength(-1),

    81 			iSdnMaximumNumberLength(-1),

    82 			iVmbTotalEntries(-1),

    83 			iVmbMaximumTextLength(-1),

    84 			iVmbMaximumNumberLength(-1),

    85 			iVmbCapabilities(0),

    86 			iMbdnTotalEntries(-1),

    87 			iMbdnMaximumTextLength(-1),

    88 			iMbdnMaximumNumberLength(-1),

    89 			iMbdnCapabilities(0),

    90 			iSecondNameMaximumFieldsPerEntry(-1),

    91 			iSecondNameMaximumLength(-1),

    92 			iEmailMaximumFieldsPerEntry(-1),

    93 			iEmailMaximumLength(-1),

    94 			iAdditionalNumberMaximumFieldsPerEntry(-1),

    95 			iAdditionalNumberMaximumLength(-1)

    96 			{

    97 			}

    98 		

    99 		//Abbriviated Dailling Numbers

   100 		TInt iAdnTotalEntries; 

   101 		TInt iAdnMaximumTextLength;

   102 		TInt iAdnMaximumNumberLength;

   103 

   104 		//Fixed Dialling numbers

   105 		TInt iFdnTotalEntries;

   106 		TInt iFdnMaximumTextLength;

   107 		TInt iFdnMaximumNumberLength;

   108 

   109 		//Service Dialling numbers

   110 		TInt iSdnTotalEntries;

   111 		TInt iSdnMaximumTextLength;

   112 		TInt iSdnMaximumNumberLength;

   113 

   114 		//Voice Mail Box

   115 		TInt iVmbTotalEntries;

   116 		TInt iVmbMaximumTextLength;

   117 		TInt iVmbMaximumNumberLength;

   118 		TInt iVmbCapabilities;

   119 

   120 		//Mailbox dialling numbers

   121 		TInt iMbdnTotalEntries;

   122 		TInt iMbdnMaximumTextLength;

   123 		TInt iMbdnMaximumNumberLength;

   124 		TInt iMbdnCapabilities;

   125 		

   126 		//3G Information - Second Names

   127 		TInt iSecondNameMaximumFieldsPerEntry;

   128 		TInt iSecondNameMaximumLength;

   129 

   130 		//3G Information - Email Address

   131 		TInt iEmailMaximumFieldsPerEntry;

   132 		TInt iEmailMaximumLength;

   133 

   134 		//3G Information - Additional Number

   135 		TInt iAdditionalNumberMaximumFieldsPerEntry;

   136 		TInt iAdditionalNumberMaximumLength;

   137 		};

   138 	

   139 	

   140 	struct TSmsData

   141 		{

   142 	public:	

   143 	    TBuf8<231> iSmsMsg;

   144 	    TBuf<KMaxAddressBufferSize> iServiceCentre;

   145 	    RMobilePhone::TMobileTON iMobileScTON;

   146 	    RMobilePhone::TMobileNPI iMobileScNPI;

   147 	    TInt8 iMessageStatus;

   148 		};

   149 	

   150 	}

   151 

   152 

   153 class MLtsyDispatchPhonebookStoreReadEntry : public MLtsyDispatchInterface

   154 	{

   155 public:

   156 

   157 	static const TInt KLtsyDispatchPhonebookStoreReadEntryApiId = KDispatchPhonebookFuncUnitId + 1;

   158 

   159 	/**

   160 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreReadIPC

   161 	 * request from the CTSY.

   162 	 *

   163 	 * It is a request call that is completed by invoking

   164 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreReadEntryComp()

   165 	 *

   166 	 * Implementation of this interface should request to read a number of entries from a given phonebook.

   167 	 * The entries are returned in the callback.

   168 	 *

   169 	 *

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

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

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

   173 	 * 

   174 	 *

   175 	 * @return KErrNone on success, otherwise another error code indicating the

   176 	 * failure.

   177 	 * 

   178 	 * @see RMobilePhoneBookStore::Read()

   179 	 */

   180 	virtual TInt HandleStoreReadEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex, TInt aNumberOfSlots) = 0;

   181 

   182 	}; // class MLtsyDispatchPhonebookStoreReadEntry

   183 

   184 

   185 

   186 class MLtsyDispatchPhonebookStoreDeleteEntry : public MLtsyDispatchInterface

   187 	{

   188 public:

   189 

   190 	static const TInt KLtsyDispatchPhonebookStoreDeleteEntryApiId = KDispatchPhonebookFuncUnitId + 2;

   191 

   192 	/**

   193 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreDeleteIPC

   194 	 * request from the CTSY.

   195 	 *

   196 	 * It is a request call that is completed by invoking

   197 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteEntryComp()

   198 	 *

   199 	 * Implementation of this interface should request to delete an entry from a given phonebook, the

   200 	 * callback indicates when the operation has been completed.

   201 	 *

   202 	 *

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

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

   205 	 *

   206 	 *

   207 	 * @return KErrNone on success, otherwise another error code indicating the

   208 	 * failure.

   209 	 * 

   210 	 * @see RMobilePhoneBookStore::Delete()

   211 	 * 

   212 	 */

   213 	virtual TInt HandleStoreDeleteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, TInt aIndex) = 0;

   214 

   215 	}; // class MLtsyDispatchPhonebookStoreDeleteEntry

   216 

   217 

   218 

   219 class MLtsyDispatchPhonebookStoreCache : public MLtsyDispatchInterface

   220 	{

   221 public:

   222 

   223 	static const TInt KLtsyDispatchPhonebookStoreCacheApiId = KDispatchPhonebookFuncUnitId + 3;

   224 

   225 	/**

   226 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreCacheIPC

   227 	 * request from the CTSY.

   228 	 *

   229 	 * It is a request call that is completed by invoking

   230 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreCacheComp()

   231 	 *

   232 	 * Implementation of this interface should request to cache a given phonebook, the entire 

   233 	 * phonebook entries are returned in the callback.

   234 	 *

   235 	 *

   236 	 * @param aPhonebook The phonebook to cache.

   237 	 *

   238 	 *

   239 	 * @return KErrNone on success, otherwise another error code indicating the

   240 	 * failure.

   241 	 */

   242 	virtual TInt HandleStoreCacheReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;

   243 

   244 	}; // class MLtsyDispatchPhonebookStoreCache

   245 

   246 

   247 

   248 class MLtsyDispatchPhonebookStoreCacheCancel : public MLtsyDispatchInterface

   249 	{

   250 public:

   251 

   252 	static const TInt KLtsyDispatchPhonebookStoreCacheCancelApiId = KDispatchPhonebookFuncUnitId + 4;

   253 

   254 	/**

   255 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreCacheCancelIPC

   256 	 * request from the CTSY.

   257 	 *

   258 	 * It is a request call that has no complete call.

   259 	 *

   260 	 *

   261 	 * Implementation of this interface should request to cancel an outstanding cache of a given phonebook.

   262 	 *

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

   264 	 *

   265 	 *

   266 	 * @return KErrNone on success, otherwise another error code indicating the

   267 	 * failure.

   268 	 */

   269 	virtual TInt HandleStoreCacheCancelReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;

   270 

   271 	}; // class MLtsyDispatchPhonebookStoreCacheCancel

   272 

   273 

   274 

   275 class MLtsyDispatchPhonebookStoreGetPhonebookInfo : public MLtsyDispatchInterface

   276 	{

   277 public:

   278 

   279 	static const TInt KLtsyDispatchPhonebookStoreGetPhonebookInfoApiId = KDispatchPhonebookFuncUnitId + 5;

   280 

   281 	/**

   282 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreGetInfoIPC

   283 	 * request from the CTSY.

   284 	 *

   285 	 * It is a request call that is completed by invoking

   286 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreGetPhonebookInfoComp()

   287 	 *

   288 	 * Implementation of this interface should request to get the information of a given phonebook. The 

   289 	 * callback should be completed with the information.

   290 	 * 

   291 	 * This call to the LTSY is only used when the CTSY requires the information about the number of used entries

   292 	 * in a phonebook, thus calls to RMobilePhoneBookStore::GetInfo() on cached phonebooks can be completed immediately 

   293 	 * as the CTSY will already hold this information.

   294 	 *

   295 	 *

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

   297 	 *

   298 	 *

   299 	 * @return KErrNone on success, otherwise another error code indicating the

   300 	 * failure.

   301 	 * 

   302 	 * @see RMobilePhoneBookStore::GetInfo()

   303 	 * 

   304 	 */

   305 	virtual TInt HandleStoreGetPhonebookInfoReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;

   306 

   307 	}; // class MLtsyDispatchPhonebookStoreGetPhonebookInfo

   308 

   309 

   310 

   311 class MLtsyDispatchPhonebookStoreInitialise : public MLtsyDispatchInterface

   312 	{

   313 public:

   314 

   315 	static const TInt KLtsyDispatchPhonebookStoreInitialiseApiId = KDispatchPhonebookFuncUnitId + 6;

   316 

   317 	/**

   318 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreInitIPC

   319 	 * request from the CTSY.

   320 	 *

   321 	 * It is a request call that is completed by invoking

   322 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreInitialiseComp()

   323 	 *

   324 	 * Implementation of this interface should request to initialise the phonebook store, the callback should

   325 	 * be completed when store initialisation is completed.

   326 	 *

   327 	 *

   328 	 * @return KErrNone on success, otherwise another error code indicating the

   329 	 * failure.

   330 	 */

   331 	virtual TInt HandleStoreInitialiseReqL() = 0;

   332 

   333 	}; // class MLtsyDispatchPhonebookStoreInitialise

   334 

   335 

   336 

   337 class MLtsyDispatchPhonebookStoreDeleteAll : public MLtsyDispatchInterface

   338 	{

   339 public:

   340 

   341 	static const TInt KLtsyDispatchPhonebookStoreDeleteAllApiId = KDispatchPhonebookFuncUnitId + 7;

   342 

   343 	/**

   344 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreDeleteAllIPC

   345 	 * request from the CTSY.

   346 	 *

   347 	 * It is a request call that is completed by invoking

   348 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreDeleteAllComp()

   349 	 *

   350 	 * Implementation of this interface should request to delete all entries from a given phonebook, the

   351 	 * callback indicates when the operation is completed.

   352 	 *

   353 	 *

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

   355 	 *

   356 	 *

   357 	 * @return KErrNone on success, otherwise another error code indicating the

   358 	 * failure.

   359 	 * 

   360 	 * @see RMobilePhoneBookStore::DeleteAll()

   361 	 * 

   362 	 */

   363 	virtual TInt HandleStoreDeleteAllReqL(DispatcherPhonebook::TPhonebook aPhonebook) = 0;

   364 

   365 	}; // class MLtsyDispatchPhonebookStoreDeleteAll

   366 

   367 

   368 

   369 class MLtsyDispatchPhonebookStoreWriteEntry : public MLtsyDispatchInterface

   370 	{

   371 public:

   372 

   373 	static const TInt KLtsyDispatchPhonebookStoreWriteEntryApiId = KDispatchPhonebookFuncUnitId + 8;

   374 

   375 	/**

   376 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneBookStoreWriteIPC

   377 	 * request from the CTSY.

   378 	 *

   379 	 * It is a request call that is completed by invoking

   380 	 * CCtsyDispatcherCallback::CallbackPhonebookStoreWriteEntryComp()

   381 	 *

   382 	 * Implementation of this interface should request to write an entry to a given phonebook.

   383 	 * The callback indicates when the operation is complete.

   384 	 *

   385 	 *

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

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

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

   389 	 *

   390 	 *

   391 	 * @return KErrNone on success, otherwise another error code indicating the

   392 	 * failure.

   393 	 * 

   394 	 * @see RMobilePhoneBookStore::Write()

   395 	 * @see CPhoneBookBuffer()

   396 	 * @see CPhoneBookEntry::InternalizeFromTlvEntry()

   397 	 * 

   398 	 */

   399 	virtual TInt HandleStoreWriteEntryReqL(DispatcherPhonebook::TPhonebook aPhonebook, const TDesC8& aEntry) = 0;

   400 

   401 	}; // class MLtsyDispatchPhonebookStoreWriteEntry

   402 

   403 

   404 

   405 class MLtsyDispatchPhonebookGetPhoneStoreInfo : public MLtsyDispatchInterface

   406 	{

   407 public:

   408 

   409 	static const TInt KLtsyDispatchPhonebookGetPhoneStoreInfoApiId = KDispatchPhonebookFuncUnitId + 9;

   410 

   411 	/**

   412 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetPhoneStoreInfo

   413 	 * request from the CTSY.

   414 	 *

   415 	 * It is a request call that is completed by invoking

   416 	 * CCtsyDispatcherCallback::CallbackPhonebookGetPhoneStoreInfoComp()

   417 	 *

   418 	 * Implementation of this interface should request to get the information of a given store. The 

   419 	 * callback should be completed with the information. 

   420 	 *

   421 	 *

   422 	 * @param aStoreName The name of the store to retrieve the information from (e.g. KETelIccFdnPhoneBook).

   423 	 *

   424 	 *

   425 	 * @return KErrNone on success, otherwise another error code indicating the

   426 	 * failure.

   427 	 * 

   428 	 * @see RMobilePhone::GetPhoneStoreInfo()

   429 	 */

   430 	virtual TInt HandleGetPhoneStoreInfoReqL(const TDesC& aStoreName) = 0;

   431 

   432 	}; // class MLtsyDispatchPhonebookGetPhoneStoreInfo

   433 

   434 

   435 

   436 class MLtsyDispatchPhonebookSmsStoreReadAll : public MLtsyDispatchInterface

   437 	{

   438 public:

   439 

   440 	static const TInt KLtsyDispatchPhonebookSmsStoreReadAllApiId = KDispatchPhonebookFuncUnitId + 10;

   441 

   442 	/**

   443 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreReadAllPhase1

   444 	 * request from the CTSY.

   445 	 *

   446 	 * It is a request call that is completed by invoking

   447 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadAllComp()

   448 	 *

   449 	 * Implementation of this interface should handle phase 1 of reading all entries in the SMS storage.

   450 	 *

   451 	 *

   452 	 *

   453 	 * @return KErrNone on success, otherwise another error code indicating the

   454 	 * failure.

   455 	 */

   456 	virtual TInt HandleSmsStoreReadAllReqL() = 0;

   457 

   458 	}; // class MLtsyDispatchPhonebookSmsStoreReadAll

   459 

   460 

   461 

   462 class MLtsyDispatchPhonebookSmsStoreDeleteEntry : public MLtsyDispatchInterface

   463 	{

   464 public:

   465 

   466 	static const TInt KLtsyDispatchPhonebookSmsStoreDeleteEntryApiId = KDispatchPhonebookFuncUnitId + 11;

   467 

   468 	/**

   469 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreDelete

   470 	 * request from the CTSY.

   471 	 *

   472 	 * It is a request call that is completed by invoking

   473 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteEntryComp()

   474 	 *

   475 	 * Implementation of this interface should handle deletion of an entry in the SMS storage.

   476 	 *

   477 	 * @param aIndex index of the entry to be deleted.

   478 	 *

   479 	 *

   480 	 * @return KErrNone on success, otherwise another error code indicating the

   481 	 * failure.

   482 	 */

   483 	virtual TInt HandleSmsStoreDeleteEntryReqL(TInt aIndex) = 0;

   484 

   485 	}; // class MLtsyDispatchPhonebookSmsStoreDeleteEntry

   486 

   487 

   488 

   489 class MLtsyDispatchPhonebookSmsStoreDeleteAll : public MLtsyDispatchInterface

   490 	{

   491 public:

   492 

   493 	static const TInt KLtsyDispatchPhonebookSmsStoreDeleteAllApiId = KDispatchPhonebookFuncUnitId + 12;

   494 

   495 	/**

   496 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreDeleteAll

   497 	 * request from the CTSY.

   498 	 *

   499 	 * Implementation of this interface should handle deletion of all entries in the SMS storage.

   500 	 *

   501 	 *

   502 	 * It is a request call that is completed by invoking

   503 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreDeleteAllComp()

   504 	 *

   505 	 *

   506 	 * @return KErrNone on success, otherwise another error code indicating the

   507 	 * failure.

   508 	 */

   509 	virtual TInt HandleSmsStoreDeleteAllReqL() = 0;

   510 

   511 	}; // class MLtsyDispatchPhonebookSmsStoreDeleteAll

   512 

   513 

   514 

   515 class MLtsyDispatchPhonebookSmsStoreGetInfo : public MLtsyDispatchInterface

   516 	{

   517 public:

   518 

   519 	static const TInt KLtsyDispatchPhonebookSmsStoreGetInfoApiId = KDispatchPhonebookFuncUnitId + 13;

   520 

   521 	/**

   522 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreGetInfo

   523 	 * request from the CTSY.

   524 	 *

   525 	 * Implementation of this interface should handle retrieval information of the SMS storage.

   526 	 *

   527 	 * 

   528 	 * It is a request call that is completed by invoking

   529 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreGetInfoComp()

   530 	 *

   531 	 *

   532 	 * @return KErrNone on success, otherwise another error code indicating the

   533 	 * failure.

   534 	 */

   535 	virtual TInt HandleSmsStoreGetInfoReqL() = 0;

   536 

   537 	}; // class MLtsyDispatchPhonebookSmsStoreGetInfo

   538 

   539 

   540 

   541 class MLtsyDispatchPhonebookSmsStoreReadEntry : public MLtsyDispatchInterface

   542 	{

   543 public:

   544 

   545 	static const TInt KLtsyDispatchPhonebookSmsStoreReadEntryApiId = KDispatchPhonebookFuncUnitId + 14;

   546 

   547 	/**

   548 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreRead

   549 	 * request from the CTSY.

   550 	 *

   551 	 * It is a request call that is completed by invoking

   552 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreReadEntryComp()

   553 	 *

   554 	 * Implementation of this interface should handle reading of an entry in the SMS storage.

   555 	 *

   556 	 * @param aIndex the index of the entry to read from.

   557 	 *

   558 	 *

   559 	 * @return KErrNone on success, otherwise another error code indicating the

   560 	 * failure.

   561 	 */

   562 	virtual TInt HandleSmsStoreReadEntryReqL(TInt aIndex) = 0;

   563 

   564 	}; // class MLtsyDispatchPhonebookSmsStoreReadEntry

   565 

   566 

   567 

   568 class MLtsyDispatchPhonebookSmsStoreWriteEntry : public MLtsyDispatchInterface

   569 	{

   570 public:

   571 

   572 	static const TInt KLtsyDispatchPhonebookSmsStoreWriteEntryApiId = KDispatchPhonebookFuncUnitId + 15;

   573 

   574 	/**

   575 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStoreWrite

   576 	 * request from the CTSY.

   577 	 *

   578 	 * It is a request call that is completed by invoking

   579 	 * CCtsyDispatcherCallback::CallbackPhonebookSmsStoreWriteEntryComp()

   580 	 *

   581 	 * Implementation of this interface should handle the storing of a Gsm Sms entry.

   582 	 *

   583 	 * Defines contents of a fixed-size, stored GSM SMS entry.

   584 	 *

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

   586 	 *

   587 	 * @return KErrNone on success, otherwise another error code indicating the

   588 	 * failure.

   589 	 */

   590 	virtual TInt HandleSmsStoreWriteEntryReqL(const RMobileSmsStore::TMobileGsmSmsEntryV1& aMobileGsmEntry) = 0;

   591 

   592 	}; // class MLtsyDispatchPhonebookSmsStoreWriteEntry

   593 

   594 

   595 #endif /*MLTSYDISPATCHPHONEBOOKINTERFACE_H_*/