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 // CLtsySimHandler

    15 

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

    17 #include <mmtsy_ipcdefs.h>

    18 

    19 

    20 

    21 #include "cltsysimhandler.h"

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

    23 #include "ltsymacros.h"

    24 

    25 

    26 

    27 CLtsySimHandler::CLtsySimHandler(

    28 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    29 	: iCtsyDispatcherCallback(aCtsyDispatcherCallback)

    30 	{

    31 	}

    32 

    33 	

    34 CLtsySimHandler::~CLtsySimHandler()

    35 	{

    36 	}

    37 

    38 

    39 CLtsySimHandler* CLtsySimHandler::NewLC(

    40 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    41 	{

    42 	TSYLOGENTRYEXIT;

    43 	CLtsySimHandler* self = new (ELeave) CLtsySimHandler(aCtsyDispatcherCallback);

    44 	CleanupStack::PushL(self);

    45 	self->ConstructL();

    46 	return self;

    47 	}

    48 

    49 

    50 CLtsySimHandler* CLtsySimHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    51 	{

    52 	TSYLOGENTRYEXIT;

    53 	CLtsySimHandler* self=

    54 			CLtsySimHandler::NewLC(aCtsyDispatcherCallback);

    55 	CleanupStack::Pop(self);

    56 	return self;

    57 	}

    58 

    59 

    60 void CLtsySimHandler::ConstructL()

    61 /**

    62  * Second phase constructor.

    63  */

    64 	{

    65 	TSYLOGENTRYEXIT;

    66 	

    67 	

    68 	} // CLtsySimHandler::ConstructL

    69 

    70 TBool CLtsySimHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

    71 /**

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

    73  * 

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

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

    76  */

    77 	{

    78 

    79 	

    80 	switch(aDispatchApiId)

    81 		{

    82 		// Insert ApiIds when support is provided in LTSY e.g.

    83 		// case MLtsyDispatchPhoneBootNotifySimStatusReady::KLtsyDispatchPhoneBootNotifySimStatusReadyApiId: return ETrue;

    84 		

    85 		default:

    86 			return EFalse;

    87 		}

    88 	}

    89 

    90 void CLtsySimHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup /*aIdGroup*/, TUint32& /*aIndIdBitMask*/)

    91 /**

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

    93  * 

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

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

    96  */

    97 	{

    98 

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

   100 	/*

   101 	if(aIdGroup == EIndIdGroup1)

   102 		aIndIdBitMask = KLtsyDispatchPhoneNotifyNetworkModeChangeIndId | 

   103 						KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId | 

   104 						KLtsyDispatchPhoneNotifySignalStrengthChangeIndId;

   105 	else

   106 		aIndIdBitMask = 0; //no indicators from other groups supported

   107 	*/

   108 	}

   109 

   110 

   111 TInt CLtsySimHandler::HandleGetApnControlListServiceStatusReqL()

   112 /**

   113  * This request is completed by invoking

   114  * CCtsyDispatcherCallback::CallbackSimGetApnControlListServiceStatusComp()

   115  *

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

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

   118  */

   119 	{

   120 	TSYLOGENTRYEXIT;

   121 

   122 	TInt ret = KErrNotSupported;

   123 

   124 	// TODO: Add implementation here.......

   125 

   126 

   127 	return TSYLOGSETEXITERR(ret);

   128 	} // CLtsySimHandler::HandleGetApnControlListServiceStatusReqL

   129 

   130 

   131 TInt CLtsySimHandler::HandleDeleteApnNameReqL(TUint32 /*aIndex*/)

   132 /**

   133  * This request is completed by invoking

   134  * CCtsyDispatcherCallback::CallbackSimDeleteApnNameComp()

   135  *

   136  * @param aIndex The index of the entry to delete.

   137  *

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

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

   140  */

   141 	{

   142 	TSYLOGENTRYEXIT;

   143 

   144 	TInt ret = KErrNotSupported;

   145 

   146 	// TODO: Add implementation here.......

   147 

   148 

   149 	return TSYLOGSETEXITERR(ret);

   150 	} // CLtsySimHandler::HandleDeleteApnNameReqL

   151 

   152 

   153 TInt CLtsySimHandler::HandleEnumerateApnEntriesReqL()

   154 /**

   155  * This request is completed by invoking

   156  * CCtsyDispatcherCallback::CallbackSimEnumerateApnEntriesComp()

   157  *

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

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

   160  */

   161 	{

   162 	TSYLOGENTRYEXIT;

   163 

   164 	TInt ret = KErrNotSupported;

   165 

   166 	// TODO: Add implementation here.......

   167 

   168 

   169 	return TSYLOGSETEXITERR(ret);

   170 	} // CLtsySimHandler::HandleEnumerateApnEntriesReqL

   171 

   172 

   173 TInt CLtsySimHandler::HandleChangeSecurityCodeReqL(RMobilePhone::TMobilePhoneSecurityCode /*aSecCode*/,

   174 												   const RMobilePhone::TMobilePhonePasswordChangeV1& /*aPasswds*/)

   175 /**

   176  * This request is completed by invoking

   177  * CCtsyDispatcherCallback::CallbackSimChangeSecurityCodeComp()

   178  *

   179  * @param aSecCode The security code to be changed.

   180  * @param aPasswds The old and the new values of the security code.

   181  *

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

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

   184  */

   185 	{

   186 	TSYLOGENTRYEXIT;

   187 

   188 	TInt ret = KErrNotSupported;

   189 

   190 	// TODO: Add implementation here.......

   191 

   192 

   193 

   194 	return TSYLOGSETEXITERR(ret);

   195 	} // CLtsySimHandler::HandleChangeSecurityCodeReqL

   196 

   197 

   198 TInt CLtsySimHandler::HandleSetFdnSettingReqL(RMobilePhone::TMobilePhoneFdnSetting /*aFdnSetting*/)

   199 /**

   200  * This request is completed by invoking

   201  * CCtsyDispatcherCallback::CallbackSimSetFdnSettingComp()

   202  *

   203  * @param aFdnSetting The FDN setting.

   204  *

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

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

   207  */

   208 	{

   209 	TSYLOGENTRYEXIT;

   210 

   211 	TInt ret = KErrNotSupported;

   212 

   213 	// TODO: Add implementation here.......

   214 

   215 

   216 

   217 	return TSYLOGSETEXITERR(ret);

   218 	} // CLtsySimHandler::HandleSetFdnSettingReqL

   219 

   220 

   221 TInt CLtsySimHandler::HandleGetCustomerServiceProfileReqL()

   222 /**

   223  * This request is completed by invoking

   224  * CCtsyDispatcherCallback::CallbackSimGetCustomerServiceProfileComp()

   225  *

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

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

   228  */

   229 	{

   230 	TSYLOGENTRYEXIT;

   231 

   232 	TInt ret = KErrNotSupported;

   233 

   234 	// TODO: Add implementation here.......

   235 

   236 

   237 	return TSYLOGSETEXITERR(ret);

   238 	} // CLtsySimHandler::HandleGetCustomerServiceProfileReqL

   239 

   240 

   241 TInt CLtsySimHandler::HandleGetSubscriberIdReqL()

   242 /**

   243  * This request is completed by invoking

   244  * CCtsyDispatcherCallback::CallbackSimGetSubscriberIdComp()

   245  *

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

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

   248  */

   249 	{

   250 	TSYLOGENTRYEXIT;

   251 

   252 	TInt ret = KErrNotSupported;

   253 

   254 	// TODO: Add implementation here.......

   255 

   256 

   257 	return TSYLOGSETEXITERR(ret);

   258 	} // CLtsySimHandler::HandleGetSubscriberIdReqL

   259 

   260 

   261 TInt CLtsySimHandler::HandleAppendApnNameReqL(const RMobilePhone::TAPNEntryV3& /*aEntry*/)

   262 /**

   263  * This request is completed by invoking

   264  * CCtsyDispatcherCallback::CallbackSimAppendApnNameComp()

   265  *

   266  * @param aEntry The entry to append to the APN list.

   267  *

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

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

   270  */

   271 	{

   272 	TSYLOGENTRYEXIT;

   273 

   274 	TInt ret = KErrNotSupported;

   275 

   276 	// TODO: Add implementation here.......

   277 

   278 

   279 

   280 	return TSYLOGSETEXITERR(ret);

   281 	} // CLtsySimHandler::HandleAppendApnNameReqL

   282 

   283 

   284 TInt CLtsySimHandler::HandleGetActiveIccApplicationTypeReqL()

   285 /**

   286  * This request is completed by invoking

   287  * CCtsyDispatcherCallback::CallbackSimGetActiveIccApplicationTypeComp()

   288  *

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

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

   291  */

   292 	{

   293 	TSYLOGENTRYEXIT;

   294 

   295 	TInt ret = KErrNotSupported;

   296 

   297 	// TODO: Add implementation here.......

   298 

   299 

   300 	return TSYLOGSETEXITERR(ret);

   301 	} // CLtsySimHandler::HandleGetActiveIccApplicationTypeReqL

   302 

   303 

   304 TInt CLtsySimHandler::HandleSetIccMessageWaitingIndicatorsReqL(const RMobilePhone::TMobilePhoneMessageWaitingV1& /*aIndicators*/)

   305 /**

   306  * This request is completed by invoking

   307  * CCtsyDispatcherCallback::CallbackSimSetIccMessageWaitingIndicatorsComp()

   308  *

   309  * @param aIndicators The message waiting indicators to set.

   310  *

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

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

   313  */

   314 	{

   315 	TSYLOGENTRYEXIT;

   316 

   317 	TInt ret = KErrNotSupported;

   318 

   319 	// TODO: Add implementation here.......

   320 

   321 

   322 	return TSYLOGSETEXITERR(ret);

   323 	} // CLtsySimHandler::HandleSetIccMessageWaitingIndicatorsReqL

   324 

   325 

   326 TInt CLtsySimHandler::HandleSetApnControlListServiceStatusReqL(RMobilePhone::TAPNControlListServiceStatus /*aStatus*/)

   327 /**

   328  * This request is completed by invoking

   329  * CCtsyDispatcherCallback::CallbackSimSetApnControlListServiceStatusComp()

   330  *

   331  * @param aStatus The service status to set.

   332  *

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

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

   335  */

   336 	{

   337 	TSYLOGENTRYEXIT;

   338 

   339 	TInt ret = KErrNotSupported;

   340 

   341 	// TODO: Add implementation here.......

   342 

   343 

   344 	return TSYLOGSETEXITERR(ret);

   345 	} // CLtsySimHandler::HandleSetApnControlListServiceStatusReqL

   346 

   347 

   348 TInt CLtsySimHandler::HandleGetApnNameReqL(TUint32 /*aIndex*/)

   349 /**

   350  * This request is completed by invoking

   351  * CCtsyDispatcherCallback::CallbackSimGetApnNameComp()

   352  *

   353  * @param aIndex The index of the APN entry to get from LTSY.

   354  *

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

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

   357  */

   358 	{

   359 	TSYLOGENTRYEXIT;

   360 

   361 	TInt ret = KErrNotSupported;

   362 

   363 	// TODO: Add implementation here.......

   364 

   365 

   366 	return TSYLOGSETEXITERR(ret);

   367 	} // CLtsySimHandler::HandleGetApnNameReqL

   368 

   369 

   370 TInt CLtsySimHandler::HandleSimRefreshDoneReqL(TInt /*aError*/)

   371 /**

   372  * This request has no associated callback.

   373  *

   374  * @param aError The error which has occured during a SIM refresh, KErrNone if no error.

   375  *

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

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

   378  */

   379 	{

   380 	TSYLOGENTRYEXIT;

   381 

   382 	TInt ret = KErrNotSupported;

   383 

   384 	// TODO: Add implementation here.......

   385 

   386 

   387 

   388 	return TSYLOGSETEXITERR(ret);

   389 	} // CLtsySimHandler::HandleSimRefreshDoneSyncL

   390 

   391 TInt CLtsySimHandler::HandleGetServiceTableReqL(

   392 							RMobilePhone::TMobilePhoneServiceTable /*aServiceTable*/)

   393 /**

   394  * This request is completed by invoking

   395  * CCtsyDispatcherCallback::CallbackSimGetServiceTableComp()

   396  * 

   397  * @param aServiceTable Service table to get information about.

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

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

   400  */

   401 	{

   402 	TSYLOGENTRYEXIT;

   403 

   404 	TInt ret = KErrNotSupported;

   405 

   406 	//TO DO: Add implementation here.......

   407 

   408 

   409 	

   410 	return TSYLOGSETEXITERR(ret);

   411 	} // CLtsySimHandler::HandleGetServiceTableReqL

   412 

   413 TInt CLtsySimHandler::HandleGetIccMessageWaitingIndicatorsReqL()

   414 /**

   415  * This request is completed by invoking

   416  * CCtsyDispatcherCallback::CallbackSimGetIccMessageWaitingIndicatorsComp()

   417  * 

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

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

   420  */

   421 	{

   422 	TSYLOGENTRYEXIT;

   423 

   424 	TInt ret = KErrNotSupported;

   425 	

   426 	//TO DO: Add implementation here.......

   427 

   428 

   429 	return TSYLOGSETEXITERR(ret);

   430 	} // CLtsySimHandler::HandleGetIccMessageWaitingIndicatorsReqL

   431 

   432 TInt CLtsySimHandler::HandleSimLockActivateReqL(const TDesC& /*aPassword*/, RMmCustomAPI::TLockNumber /*aLockNumber*/)

   433 /**

   434  * This request is completed by invoking

   435  * CCtsyDispatcherCallback::CallbackSimSimLockActivateComp()

   436  *

   437  * @param aPassword The password used for the SIM Lock activation.

   438  * @param aLockNumber The lock number that defines SIM Lock types.

   439  *

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

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

   442  */

   443 	{

   444 	TSYLOGENTRYEXIT;

   445 

   446 	TInt ret = KErrNotSupported;

   447 

   448 	//TO DO: Add implementation here.......

   449 	

   450 

   451 

   452 	return TSYLOGSETEXITERR(ret);

   453 	} // CLtsySimHandler::HandleSimLockActivateReqL

   454 

   455 

   456 TInt CLtsySimHandler::HandleSimLockDeActivateReqL(const TDesC& /*aPassword*/, RMmCustomAPI::TLockNumber /*aLockNumber*/)

   457 /**

   458  * This request is completed by invoking

   459  * CCtsyDispatcherCallback::CallbackSimSimLockDeActivateComp()

   460  *

   461  * @param aPassword The password used for the SIM Lock deactivation.

   462  * @param aLockNumber The lock number that defines SIM Lock types.

   463  *

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

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

   466  */

   467 	{

   468 	TSYLOGENTRYEXIT;

   469 

   470 	TInt ret = KErrNotSupported;

   471 

   472 	//TO DO: Add implementation here.......

   473 	

   474 

   475 

   476 	return TSYLOGSETEXITERR(ret);

   477 	} // CLtsySimHandler::HandleSimLockDeActivateReqL

   478 

   479 

   480 TInt CLtsySimHandler::HandleGetAnswerToResetReqL(const TDesC8& /*aAnswerToReset*/)

   481 /**

   482  * This request is completed by invoking

   483  * CCtsyDispatcherCallback::CallbackSimGetAnswerToResetComp()

   484  *

   485  * @param aAnswerToReset The answer to reset information which contains details of the request.

   486  * 

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

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

   489  */

   490 	{

   491 	TSYLOGENTRYEXIT;

   492 

   493 	TInt ret = KErrNotSupported;

   494 

   495 	//TO DO: Add implementation here.......

   496 	

   497 

   498 

   499 	return TSYLOGSETEXITERR(ret);

   500 	} // CLtsySimHandler::HandleGetAnswerToResetReqL

   501 

   502 

   503 TInt CLtsySimHandler::HandleGetSimCardReaderStatusReqL()

   504 /**

   505  * This request is completed by invoking

   506  * CCtsyDispatcherCallback::CallbackSimGetSimCardReaderStatusComp()

   507  *

   508  * @param aSimCardReaderStatus The sim card reader status information which contains details of the request.

   509  * 

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

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

   512  */

   513 	{

   514 	TSYLOGENTRYEXIT;

   515 

   516 	TInt ret = KErrNotSupported;

   517 

   518 	//TO DO: Add implementation here.......

   519 	

   520 

   521 	return TSYLOGSETEXITERR(ret);

   522 	} // CLtsySimHandler::HandleGetSimCardReaderStatusReqL

   523 

   524 

   525 TInt CLtsySimHandler::HandleGetSimAuthenticationEapSimDataReqL(const TDesC8& /*aRandomParameters*/, TInt /*aRFStateInfo*/)

   526 /**

   527  * This request is completed by invoking

   528  * CCtsyDispatcherCallback::CallbackSimGetSimAuthenticationEapSimDataComp()

   529  *

   530  * @param aRandomParameters The random parameters from the client.

   531  * @param aRFStateInfo The RF state info.

   532  *

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

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

   535  */

   536 	{

   537 	TSYLOGENTRYEXIT;

   538 

   539 	TInt ret = KErrNotSupported;

   540 

   541 	//TO DO: Add implementation here.......

   542 	

   543 

   544 

   545 	return TSYLOGSETEXITERR(ret);

   546 	} // CLtsySimHandler::HandleGetSimAuthenticationEapSimDataReqL

   547 

   548 TInt CLtsySimHandler::HandleGetSimAuthenticationEapAkaDataReqL(const TDesC8& /*aRandomParameters*/, const TDesC8& /*aAUTN*/, TInt /*aRFStateInfo*/)

   549 /**

   550  * This request is completed by invoking

   551  * CCtsyDispatcherCallback::CallbackSimGetSimAuthenticationEapAkaDataComp()

   552  *

   553  * @param aRandomParameters The random parameters from the client.

   554  * @param aAUTN The AUTN parameter. AUTN is an authentication value generated by

   555  *        the Authentication Centre, which, together with the random parameters, authenticates the server to the peer, 128 bits.

   556  * @param aRFStateInfo The RF state info.

   557  *

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

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

   560  */

   561 	{

   562 	TSYLOGENTRYEXIT;

   563 

   564 	TInt ret = KErrNotSupported;

   565 

   566 	//TO DO: Add implementation here.......

   567 	

   568 

   569 

   570 	return TSYLOGSETEXITERR(ret);

   571 	} // CLtsySimHandler::HandleGetSimAuthenticationEapAkaDataReqL

   572 

   573 

   574 TInt CLtsySimHandler::HandlePowerSimOffReqL()

   575 /**

   576  * This request is completed by invoking

   577  * CCtsyDispatcherCallback::CallbackSimPowerSimOffComp()

   578  *

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

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

   581  */

   582 	{

   583 	TSYLOGENTRYEXIT;

   584 

   585 	TInt ret = KErrNotSupported;

   586 

   587 	// TODO: Add implementation here.......

   588 

   589 

   590 	return TSYLOGSETEXITERR(ret);

   591 	} // CLtsySimHandler::HandlePowerSimOffReqL

   592 

   593 

   594 TInt CLtsySimHandler::HandlePowerSimOnReqL()

   595 /**

   596  * This request is completed by invoking

   597  * CCtsyDispatcherCallback::CallbackSimPowerSimOnComp()

   598  *

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

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

   601  */

   602 	{

   603 	TSYLOGENTRYEXIT;

   604 

   605 	TInt ret = KErrNotSupported;

   606 

   607 	// TODO: Add implementation here.......

   608 

   609 

   610 	return TSYLOGSETEXITERR(ret);

   611 	} // CLtsySimHandler::HandlePowerSimOnReqL

   612 

   613 TInt CLtsySimHandler::HandleReadSimFileReqL(const TDesC8& /*aPath*/, TUint16 /*aOffset*/, TUint16 /*aSize*/)

   614 /**

   615  * This request is completed by invoking

   616  * CCtsyDispatcherCallback::CallbackSimReadSimFileComp()

   617  *

   618  * @param aPath The absolute file path of the SIM file in the file system of the SIM.

   619  * see ETSI TS 131 102 Under "Files of USIM"

   620  * @param aOffset The value of the Offset, the offset is related with the type of SIM file being read.

   621  * @param aSize The amount of bytes to be read from the SIM file.

   622  *

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

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

   625  */

   626 	{

   627 	TSYLOGENTRYEXIT;

   628 

   629 	TInt ret = KErrNotSupported;

   630 

   631 	// TODO: Add implementation here.......

   632 

   633 

   634 

   635 	return TSYLOGSETEXITERR(ret);

   636 	} // CLtsySimHandler::HandleReadSimFileReqL

   637 

   638 TInt CLtsySimHandler::HandleSimSendApduRequestReqL(TUint8 /*aServiceType*/, TUint8 /*aCardReaderNumber*/, TUint8 /*aApplicationType*/, const TDesC8& /*aCommandData*/)

   639 /**

   640  * This request is completed by invoking

   641  * CCtsyDispatcherCallback::CallbackSimSendApduRequestComp()

   642  *

   643  * @param aServiceType The value for the service type of the request.

   644  * @param aCardReaderNumber The value for the card reader number of the request.

   645  * @param aApplicationType The value for the application type of the request.

   646  * @param aCommandData The transparent data to be conveyed to the Baseband.

   647  *

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

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

   650  */

   651 	{

   652 	TSYLOGENTRYEXIT;

   653 

   654 	TInt ret = KErrNotSupported;

   655 

   656 	// TODO: Add implementation here.......

   657 

   658 

   659 

   660 	return TSYLOGSETEXITERR(ret);

   661 	} // CLtsySimHandler::HandleSimSendApduRequestReqL

   662 

   663 TInt CLtsySimHandler::HandleSimSendApduRequestV2ReqL(TUint8 /*aCardReaderId*/, const TDesC8& /*aCommandData*/)

   664 /**

   665  * This request is completed by invoking

   666  * CCtsyDispatcherCallback::CallbackSimSendApduRequestV2Comp()

   667  *

   668  * @param aCardReaderId The value for the card reader Id of the request.

   669  * @param aCommandData The transparent data to be conveyed to the Baseband.

   670  *

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

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

   673  */

   674 	{

   675 	TSYLOGENTRYEXIT;

   676 

   677 	TInt ret = KErrNotSupported;

   678 

   679 	// TODO: Add implementation here.......

   680 

   681 

   682 

   683 	return TSYLOGSETEXITERR(ret);

   684 	} // CLtsySimHandler::HandleSimSendApduRequestV2ReqL

   685 

   686 

   687 TInt CLtsySimHandler::HandleSimWarmResetReqL()

   688 /**

   689  * This request is completed by invoking

   690  * CCtsyDispatcherCallback::CallbackSimSimWarmResetComp()

   691  *

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

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

   694  */

   695 	{

   696 	TSYLOGENTRYEXIT;

   697 

   698 	TInt ret = KErrNotSupported;

   699 

   700 	// TODO: Add implementation here.......

   701 

   702 

   703 	return TSYLOGSETEXITERR(ret);

   704 	} // CLtsySimHandler::HandleSimWarmResetReqL

   705 

   706 

   707 TInt CLtsySimHandler::HandleSetSimMessageStatusReadReqL(const TTime& /*aTimestamp*/, TInt /*aTimezoneDiff*/)

   708 /**

   709  * This request is completed by invoking

   710  * CCtsyDispatcherCallback::CallbackSimSetSimMessageStatusRead()

   711  *

   712  * No error code is returned to the ETel client - if no SMS message with matching timestamp is identified

   713  * on the SIM then this error will be silently ignored.

   714  *

   715  * @param aTimestamp timestamp that uniquely identifies a particular message in the message store.

   716  * @param aTimezoneDiff the difference, expressed in quarters of an hour, between the service centre local time and GMT

   717  *

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

   719  * failure.

   720  * 

   721  * @see RMmCustomAPI::SetSimMessageStatusRead()

   722  **/

   723 	{

   724 	TSYLOGENTRYEXIT;

   725 

   726 	TInt ret = KErrNotSupported;

   727 

   728 	// TODO: Add implementation here.......

   729 

   730 

   731 	return TSYLOGSETEXITERR(ret);

   732 	} // CLtsySimHandler::HandleSetSimMessageStatusReadReqL