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 Sat related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHSATINTERFACE_H_

    28 #define MLTSYDISPATCHSATINTERFACE_H_

    29 

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

    31 

    32 namespace DispatcherSat

    33 	{

    34 	

    35 	/**

    36 	 * This namespace contains all types relating to the SAT dispatcher.

    37 	 */

    38 	

    39 	/**

    40 	 * Enum containing the SS status

    41 	 */

    42 	enum TSsStatus

    43 		{

    44 		ENotBusy,

    45 		ESsBusy,

    46 		EUssdBusy

    47 		};

    48 	

    49 	}

    50 

    51 class MLtsyDispatchSatSmsDeliverReport : public MLtsyDispatchInterface

    52 	{

    53 public:

    54 

    55 	static const TInt KLtsyDispatchSatSmsDeliverReportApiId = KDispatchSatFuncUnitId + 1;

    56 

    57 	/**

    58 	 * This API is optional and should only be used if the licensee wishes to including the

    59 	 * Dispatcher beneath their own SIM ATK TSY.

    60 	 * 

    61 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsDeliverReport

    62 	 * request from the CTSY.

    63 	 * 

    64 	 * 

    65 	 * It is a request call that does not have an associated complete callback.

    66 	 *

    67 	 * Implementation of this interface should handle the requested SMS DELIVER REPORT Tpdu as

    68 	 * a result of the CCtsyDispatcherCallback::CallbackSatCreateSmsDeliverReportInd()

    69 	 * 

    70 	 * An SMS DELIVER REPORT TPDU is carried as a RP User Data element within an RP ERROR PDU 

    71 	 * and is part of the negative acknowledgement to an SMS DELIVER or SMS STATUS REPORT.

    72 	 * 

    73 	 * An SMS DELIVER REPORT TPDU is also carried as a RP User Data element within an RP ACK PDU 

    74 	 * and is part of a positive acknowledgement to a SMS DELIVER or SMS STATUS REPORT.

    75 	 * 

    76 	 *

    77 	 * @param aSmsDeliverReportTpdu The SMS-DELIVER-REPORT TPDU element to be contained in a 

    78 	 * RP-ERROR-PDU (negative acknowledgement) or RP-ACK-PDU (a positive acknowledgement) to a

    79 	 * SMS DELIVER or SMS STATUS REPORT

    80 	 *

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

    82 	 * failure.

    83 	 */

    84 	virtual TInt HandleSmsDeliverReportReqL(const TDesC8& aSmsDeliverReportTpdu) = 0;

    85 

    86 	}; // class MLtsyDispatchSatSmsDeliverReport

    87 

    88 

    89 

    90 class MLtsyDispatchSatGetImageInstance : public MLtsyDispatchInterface

    91 	{

    92 public:

    93 

    94 	static const TInt KLtsyDispatchSatGetImageInstanceApiId = KDispatchSatFuncUnitId + 2;

    95 

    96 	/**

    97 	 * This API is optional and should only be used if the licensee wishes to including the

    98 	 * Dispatcher beneath their own SIM ATK TSY.

    99 	 * 

   100 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetImageInstance

   101 	 * request from the CTSY.

   102 	 * 

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

   104 	 * CCtsyDispatcherCallback::CallbackSatGetImageInstanceComp()

   105 	 * 

   106 	 * Implementation of this interface should retrieve an icon's image data from the UICC 

   107 	 * designated by aEfImgRecordNumber & aInstanceNumberInEfImgRecord

   108 	 *

   109 	 * @param aEfImgRecordNumber 			The record number of the icons EF(img) record for the 

   110 	 * 										icon image instance being retrieved. 

   111 	 * @param aInstanceNumberInEfImgRecord 	The record number of the icon instance, in the icons EF(img) record

   112 	 * 										for the icon image instance being retrieved. 

   113 	 *

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

   115 	 * failure.

   116 	 */

   117 	virtual TInt HandleGetImageInstanceReqL(TUint8 aEfImgRecordNumber, TUint8 aInstanceNumberInEfImgRecord) = 0;

   118 

   119 	}; // class MLtsyDispatchSatGetImageInstance

   120 

   121 

   122 class MLtsyDispatchSatGetIconData : public MLtsyDispatchInterface

   123 	{

   124 public:

   125 

   126 	static const TInt KLtsyDispatchSatGetIconDataApiId = KDispatchSatFuncUnitId + 3;

   127 

   128 	/**

   129 	 * This API is optional and should only be used if the licensee wishes to including the

   130 	 * Dispatcher beneath their own SIM ATK TSY.

   131 	 * 

   132 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetIconData

   133 	 * request from the CTSY.

   134 	 * 

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

   136 	 * CCtsyDispatcherCallback::CallbackSatGetIconDataComp()

   137 	 * 

   138 	 * Implementation of this interface should retrieve an icon's EF record from the UICC based

   139 	 * on the record number (see ETSI TS 131 102 Under EFIMG (Image) & Files of USIM)

   140 	 *

   141 	 * @param aEfImgRecordNumber 	EF(img) record number of the icon to retrieve 

   142 	 * @param aSimFilePath 			The full file path to the EF(Img) 

   143 	 * 								Bytes 	0-1 MF 			(0x3F00)

   144 	 * 								Bytes	2-3 DF(Telecom) (0x7F10) 

   145 	 * 								Bytes	4-5 DF(Graphics)(0x5F50)

   146 	 * 								Bytes	6-7 EF(Ef(Img)) 	(0x4F20)

   147 	 *

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

   149 	 * failure.

   150 	 */

   151 	virtual TInt HandleGetIconDataReqL(TUint8 aEfImgRecordNumber, const TDesC8& aSimFilePath) = 0;

   152 

   153 	}; // class MLtsyDispatchSatGetIconData

   154 

   155 

   156 

   157 class MLtsyDispatchSatGetClut : public MLtsyDispatchInterface

   158 	{

   159 public:

   160 

   161 	static const TInt KLtsyDispatchSatGetClutApiId = KDispatchSatFuncUnitId + 4;

   162 

   163 	/**

   164 	 * This API is optional and should only be used if the licensee wishes to including the

   165 	 * Dispatcher beneath their own SIM ATK TSY.

   166 	 * 

   167 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetClut

   168 	 * request from the CTSY.

   169 	 * 

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

   171 	 * CCtsyDispatcherCallback::CallbackSatGetClutComp()

   172 	 * 

   173 	 * Implementation of this interface should retrieve the CLUT (Colour Lookup Table) for an image instance 

   174 	 * designated by aEfImgRecordNumber & aInstanceNumberInEfImgRecord

   175 	 *

   176 	 * @param aEfImgRecordNumber 			The record number of the icons EF(Img) record for the 

   177 	 * 										CLUT being retrieved.

   178 	 * @param aInstanceNumberInEfImgRecord 	The record number of the icon instance, in the icons EF(Img) record

   179 	 * 										for the CLUT being retrieved.

   180 	 *

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

   182 	 * failure.

   183 	 */

   184 	virtual TInt HandleGetClutReqL(TUint8 aEfImgRecordNumber, TUint8 aInstanceNumberInEfImgRecord) = 0;

   185 

   186 	}; // class MLtsyDispatchSatGetClut

   187 

   188 

   189 

   190 class MLtsyDispatchSatGetDefaultBearerCapability : public MLtsyDispatchInterface

   191 	{

   192 public:

   193 

   194 	static const TInt KLtsyDispatchSatGetDefaultBearerCapabilityApiId = KDispatchSatFuncUnitId + 5;

   195 

   196 	/**

   197 	 * This API is optional and should only be used if the licensee wishes to including the

   198 	 * Dispatcher beneath their own SIM ATK TSY.

   199 	 * 

   200 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetBearerCapability

   201 	 * request from the CTSY.

   202 	 * 

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

   204 	 * CCtsyDispatcherCallback::CallbackSatGetDefaultBearerCapabilityComp()

   205 	 * 

   206 	 * Implementation of this interface should retrieve the current default bearer capability configuration.

   207 	 * 

   208 	 * The default bearer capability configuration (coding as defined by the access technologies) will be used 

   209 	 * by the CTSY when creating a Call Control ENVELOPE (the capability configuration parameters) if a zero length 

   210 	 * capability parameters is passed when creating the Envelope. 

   211 	 * See "ETSI TS 102 223" "Structure of ENVELOPE (CALL CONTROL)"

   212 	 * 

   213 	 * @see MLtsyDispatchSatCallAndSmsControlEnvelope::HandleCallAndSmsControlEnvelopeReqL()

   214 	 * @see CCtsyDispatcherCallback::CallbackSatCallControlEnvelopeResponseInd()

   215 	 *

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

   217 	 * failure.

   218 	 */

   219 	virtual TInt HandleGetDefaultBearerCapabilityReqL() = 0;

   220 

   221 	}; // class MLtsyDispatchSatGetDefaultBearerCapability

   222 

   223 

   224 

   225 class MLtsyDispatchSatGetSmsPpDownloadSupported : public MLtsyDispatchInterface

   226 	{

   227 public:

   228 

   229 	static const TInt KLtsyDispatchSatGetSmsPpDownloadSupportedApiId = KDispatchSatFuncUnitId + 6;

   230 

   231 	/**

   232 	 * This API is optional and should only be used if the licensee wishes to including the

   233 	 * Dispatcher beneath their own SIM ATK TSY.

   234 	 * 

   235 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsPpDdlStatus

   236 	 * request from the CTSY.

   237 	 * 

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

   239 	 * CCtsyDispatcherCallback::CallbackSatGetSmsPpDownloadSupportedComp()

   240 	 * 

   241 	 * Implementation of this interface should retrieve if the service 

   242 	 * "data download via SMS Point-to-point" is allocated and activated in the SIM Service Table

   243 	 * and return the result via CCtsyDispatcherCallback::CallbackSatGetSmsPpDownloadSupportedComp()

   244 	 * 

   245 	 * @see 3GPP TS 11.14 section 7.1

   246 	 * @see 3GPP TS 11.11 section 11.6.12

   247 	 *

   248 	 *

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

   250 	 * failure.

   251 	 */

   252 	virtual TInt HandleGetSmsPpDownloadSupportedReqL() = 0;

   253 

   254 	}; // class MLtsyDispatchSatGetSmsPpDownloadSupported

   255 

   256 

   257 

   258 class MLtsyDispatchSatGetSmsControlActivated : public MLtsyDispatchInterface

   259 	{

   260 public:

   261 

   262 	static const TInt KLtsyDispatchSatGetSmsControlActivatedApiId = KDispatchSatFuncUnitId + 7;

   263 

   264 	/**

   265 	 * This API is optional and should only be used if the licensee wishes to including the

   266 	 * Dispatcher beneath their own SIM ATK TSY.

   267 	 * 

   268 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyMoSmsControlActivation

   269 	 * request from the CTSY.

   270 	 * 

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

   272 	 * CCtsyDispatcherCallback::CallbackSatGetSmsControlActivatedComp()

   273 	 * 

   274 	 * Implementation of this interface should retrieve the current activation state of 

   275 	 * MO-SMS Control by USIM (Service n°31 in EFust).

   276 	 * 

   277 	 * @see 3GPP TS 11.11 section 11.6.16

   278 	 * @see 3GPP TS 31.102 section 4.2.8

   279 	 * 

   280 	 *

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

   282 	 * failure.

   283 	 */

   284 	virtual TInt HandleGetSmsControlActivatedReqL() = 0;

   285 

   286 	}; // class MLtsyDispatchSatGetSmsControlActivated

   287 

   288 class MLtsyDispatchSatGetAccessTechnology : public MLtsyDispatchInterface

   289 	{

   290 public:

   291 

   292 	static const TInt KLtsyDispatchSatGetAccessTechnologyApiId = KDispatchSatFuncUnitId + 8;

   293 

   294 	/**

   295 	 * This API is optional and should only be used if the licensee wishes to including the

   296 	 * Dispatcher beneath their own SIM ATK TSY.

   297 	 * 

   298 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyAccTech

   299 	 * request from the CTSY.

   300 	 * 

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

   302 	 * CCtsyDispatcherCallback::CallbackSatGetAccessTechnologyComp()

   303 	 * 

   304 	 * Implementation of this interface should cause the current access technology to be

   305 	 * sent up to the CTSY via the CallbackSatGetAccessTechnologyComp() callback.

   306 	 * 

   307 	 * This request is generated when a LOCAL INFORMATION (access technology)

   308 	 * proactive command is received from UICC.

   309 	 * 

   310 	 *

   311 	 *

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

   313 	 * failure.

   314 	 */

   315 	virtual TInt HandleGetAccessTechnologyReqL() = 0;

   316 

   317 	}; // class MLtsyDispatchSatGetAccessTechnology

   318 

   319 class MLtsyDispatchSatCellBroadcastEnvelope : public MLtsyDispatchInterface

   320 	{

   321 public:

   322 

   323 	static const TInt KLtsyDispatchSatCellBroadcastEnvelopeApiId = KDispatchSatFuncUnitId + 9;

   324 

   325 	/**

   326 	 * This API is optional and should only be used if the licensee wishes to including the

   327 	 * Dispatcher beneath their own SIM ATK TSY.

   328 	 * 

   329 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyCellBroadcast

   330 	 * request from the CTSY.

   331 	 * 

   332 	 * It is a request call that does not have an associated complete callback.

   333 	 * 

   334 	 * 

   335 	 * Implementation of this interface should hanldle Cell Broadcast Envelope commands.

   336 	 * This ENVELOPE is created as a result of a CallbackSatCreateCellBroadcastEnvelopeInd() call.

   337 	 *

   338 	 * Once the ME receives a new Cell Broadcast message and the service, if "data download via SMS-CB" is 

   339 	 * allocated and activated in the SIM Service Table and if the message identifier of the Cell Broadcast 

   340 	 * is contained within the message identifiers of the EF(CBMID), the the cell broadcast page is passed 

   341 	 * to the SIM using the ENVELOPE (CELL BROADCAST DOWNLOAD) command.

   342 	 * 

   343 	 * See "3GPP TS 11.14" Under "Cell Broadcast data download"

   344 	 * 

   345 	 *

   346 	 * @param aEnvelope BER-TLV encoded data containing an (CELL BROADCAST DOWNLOAD) ENVELOPE command. 

   347 	 *

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

   349 	 * failure.

   350 	 */

   351 	virtual TInt HandleCellBroadcastEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   352 

   353 	}; // class MLtsyDispatchSatCellBroadcastEnvelope

   354 

   355 

   356 

   357 class MLtsyDispatchSatTimingAdvance : public MLtsyDispatchInterface

   358 	{

   359 public:

   360 

   361 	static const TInt KLtsyDispatchSatTimingAdvanceApiId = KDispatchSatFuncUnitId + 10;

   362 

   363 	/**

   364 	 * This API is optional and should only be used if the licensee wishes to including the

   365 	 * Dispatcher beneath their own SIM ATK TSY.

   366 	 * 

   367 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyTimingAdvance

   368 	 * request from the CTSY.

   369 	 * 

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

   371 	 * CCtsyDispatcherCallback::CallbackSatTimingAdvanceComp()

   372 	 * 

   373 	 * Implementation of this interface should ascertain the Timing Advance measurement from the GSM/3G

   374 	 * protocol. It can then be provided to the SIM application in response to a PROVIDE LOCAL INFO 

   375 	 * proactive command.

   376 	 * 

   377 	 *

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

   379 	 * failure.

   380 	 */

   381 	virtual TInt HandleTimingAdvanceReqL() = 0;

   382 

   383 	}; // class MLtsyDispatchSatTimingAdvance

   384 

   385 

   386 

   387 class MLtsyDispatchSatSmControlResponseData : public MLtsyDispatchInterface

   388 	{

   389 public:

   390 

   391 	static const TInt KLtsyDispatchSatSmControlResponseDataApiId = KDispatchSatFuncUnitId + 11;

   392 

   393 	/**

   394 	 * This API is optional and should only be used if the licensee wishes to including the

   395 	 * Dispatcher beneath their own SIM ATK TSY.

   396 	 * 

   397 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatNotifyMoSmControlRequest

   398 	 * request from the CTSY.

   399 	 * 

   400 	 * It is a request call that does not have an associated complete callback.

   401 	 * 

   402 	 * Implementation of this interface should handle the parsed Mo Short Message Control response TLV data.

   403 	 * 

   404 	 * As a result of the ENVELOPE (MO SHORT MESSAGE CONTROL) command sent to the SIM, the SIM will respond

   405 	 * with a response TLV, this is can be passed to the LTSY via the 

   406 	 * CCtsyDispatcherCallback::CallbackSatSmControlEnvelopeResponseInd().

   407 	 * The CTSY parses this TLV, completes the RSat::NotifySmControlRequest() on the client side and passes

   408 	 * down the parsed data to the LTSY via this handler.

   409 	 * 

   410 	 * See "3GPP 11.14 - MO Short Message Control by SIM"

   411 	 *

   412 	 * @param aResult MO short message control result the SIM gives to the ME concerning whether to 

   413 	 * allow, bar or modify the proposed short message, encoded as defined in "3GPP TS 11.10-4, 27.22.8 MO SHORT MESSAGE CONTROL BY SIM" 

   414 	 * @param aRpDestinationAddress RP Destination Address of the Service Center to which the ME is proposing to send the short message.

   415 	 * If the address data is not present (zero length), then assume the RP Destination Address of the Service Center is not to be modified. 

   416 	 * @param aTpDestinationAddress TP Destination Address to which the ME is proposing to send the short message.

   417 	 * If the address data is not present (zero length), then assume the TP Destination Address is not to be modified. 

   418 	 *

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

   420 	 * failure.

   421 	 */

   422 	virtual TInt HandleSmControlResponseDataReqL(

   423 			TUint8 aResult, const TDesC8& aRpDestinationAddress, const TDesC8& aTpDestinationAddress) = 0;

   424 

   425 	}; // class MLtsyDispatchSatSmControlResponseData

   426 

   427 

   428 

   429 class MLtsyDispatchSatProvideLocationInfo : public MLtsyDispatchInterface

   430 	{

   431 public:

   432 

   433 	static const TInt KLtsyDispatchSatProvideLocationInfoApiId = KDispatchSatFuncUnitId + 12;

   434 

   435 	/**

   436 	 * This API is optional and should only be used if the licensee wishes to including the

   437 	 * Dispatcher beneath their own SIM ATK TSY.

   438 	 * 

   439 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyProvideLocalInfo

   440 	 * request from the CTSY.

   441 	 * 

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

   443 	 * CCtsyDispatcherCallback::CallbackSatProvideLocationInfoComp()

   444 	 * 

   445 	 * Implementation of this interface should cause location information data to be provided, which can then be used

   446 	 * for Call/SS/USSD Control.

   447 	 * 

   448 	 * See "3GPP TS 11.14" section 9.1.1

   449 	 * 

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

   451 	 * failure.

   452 	 */

   453 	virtual TInt HandleProvideLocationInfoReqL() = 0;

   454 

   455 	}; // class MLtsyDispatchSatProvideLocationInfo

   456 

   457 

   458 

   459 class MLtsyDispatchSatSetPollingInterval : public MLtsyDispatchInterface

   460 	{

   461 public:

   462 

   463 	static const TInt KLtsyDispatchSatSetPollingIntervalApiId = KDispatchSatFuncUnitId + 13;

   464 

   465 	/**

   466 	 * This API is optional and should only be used if the licensee wishes to including the

   467 	 * Dispatcher beneath their own SIM ATK TSY.

   468 	 * 

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

   470 	 * request from the CTSY.

   471 	 * 

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

   473 	 * CCtsyDispatcherCallback::CallbackSatSetPollingIntervalComp()

   474 	 * 

   475 	 * Implementation of this interface should attempt to update the polling interval in the LTSY.

   476 	 * 

   477 	 * A Proactive command from the UICC indicates the poll interval it requests from then onwards.

   478 	 * The CTSY then notifies the LTSY the maximum poll interval it should use in seconds 

   479 	 * (via a HandleSetPollingIntervalReqL()), the LTSY completes the request (via a CallbackSatSetPollingIntervalComp())

   480 	 * indicating the interval that will be used. If successful the CTSY then sends a terminal response, in response 

   481 	 * to the original proactive command. If unsuccessful and polling is currently off a terminal response is sent

   482 	 * with a result of Unable To Process Command, in the case where polling is currently on the request to the LTSY is 

   483 	 * re-attempted with a legacy polling interval of 25 seconds.

   484 	 * 

   485 	 * The polling interval ranges from a minimum of 5 and maximum of 255 seconds, 

   486 	 * a polling interval of zero (0) indiates that polling should be turned off.

   487 	 * 

   488 	 * See "ETSI TS 102 223" "POLL INTERVAL"

   489 	 *

   490 	 * @param aPollingInterval The polling interval in seconds indicating how often the 

   491 	 * terminal sends STATUS commands related to Proactive Polling 

   492 	 * (zero indicates Polling should be turned off) 

   493 	 *

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

   495 	 * failure.

   496 	 */

   497 	virtual TInt HandleSetPollingIntervalReqL(TUint8 aPollingInterval) = 0;

   498 

   499 	}; // class MLtsyDispatchSatSetPollingInterval

   500 

   501 

   502 

   503 class MLtsyDispatchSatSmsPpDownloadEnvelope : public MLtsyDispatchInterface

   504 	{

   505 public:

   506 

   507 	static const TInt KLtsyDispatchSatSmsPpDownloadEnvelopeApiId = KDispatchSatFuncUnitId + 14;

   508 

   509 	/**

   510 	 * This API is optional and should only be used if the licensee wishes to including the

   511 	 * Dispatcher beneath their own SIM ATK TSY.

   512 	 * 

   513 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySmsPpDdl

   514 	 * request from the CTSY.

   515 	 * 

   516 	 * It is a request call that does not have an associated complete callback.

   517 	 * 

   518 	 * Implementation of this interface should hanlde a SMS-PP DOWNLOAD, ENVELOPE command 

   519 	 * to be passed to the SIM.

   520 	 * 

   521 	 * See "3GPP 11.14" Under "SMS-PP data download"

   522 	 * 

   523 	 * @param aEnvelope BER-TLV encoded data containing an (SMS-PP DOWNLOAD) ENVELOPE command 

   524 	 *

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

   526 	 * failure.

   527 	 */

   528 	virtual TInt HandleSmsPpDownloadEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   529 

   530 	}; // class MLtsyDispatchSatSmsPpDownloadEnvelope

   531 

   532 

   533 

   534 class MLtsyDispatchSatLocalInformationNmr : public MLtsyDispatchInterface

   535 	{

   536 public:

   537 

   538 	static const TInt KLtsyDispatchSatLocalInformationNmrApiId = KDispatchSatFuncUnitId + 15;

   539 

   540 	/**

   541 	 * This API is optional and should only be used if the licensee wishes to including the

   542 	 * Dispatcher beneath their own SIM ATK TSY.

   543 	 * 

   544 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyLocalInformationNmr

   545 	 * request from the CTSY.

   546 	 * 

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

   548 	 * CCtsyDispatcherCallback::CallbackSatLocalInformationNmrComp()

   549 	 * 

   550 	 * Implementation of this interface should request Network Measurement Results (NMR).

   551 	 * They can be requested by a "LOCAL INFO" proactive command and this API is called

   552 	 * during the construction of the command's Terminal Response.

   553 	 * 

   554 	 *

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

   556 	 * failure.

   557 	 */

   558 	virtual TInt HandleLocalInformationNmrReqL() = 0;

   559 

   560 	}; // class MLtsyDispatchSatLocalInformationNmr

   561 

   562 class MLtsyDispatchSatCallAndSmsControlEnvelope : public MLtsyDispatchInterface

   563 	{

   564 public:

   565 

   566 	static const TInt KLtsyDispatchSatCallAndSmsControlEnvelopeApiId = KDispatchSatFuncUnitId + 16;

   567 

   568 	/**

   569 	 * This API is optional and should only be used if the licensee wishes to including the

   570 	 * Dispatcher beneath their own SIM ATK TSY.

   571 	 * 

   572 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsySendEnvelope

   573 	 * request from the CTSY.

   574 	 * 

   575 	 * It is a request call that does not have an associated complete callback.

   576 	 * 

   577 	 * Implementation of this interface should cause the TLV data to be sent in an ENVELOPE

   578 	 * to the UICC. This interface is used for ENVELOPE commands related to call control events. 

   579 	 * 

   580 	 *

   581 	 * @param aEnvelope BER-TLV encoded data containing a Call Control or MO SMS control by SIM ENVELOPE command. 

   582 	 *

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

   584 	 * failure.

   585 	 */

   586 	virtual TInt HandleCallAndSmsControlEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   587 

   588 	}; // class MLtsyDispatchSatCallAndSmsControlEnvelope

   589 

   590 

   591 

   592 class MLtsyDispatchSatRefreshAllowed : public MLtsyDispatchInterface

   593 	{

   594 public:

   595 

   596 	static const TInt KLtsyDispatchSatRefreshAllowedApiId = KDispatchSatFuncUnitId + 17;

   597 

   598 	/**

   599 	 * This API is optional and should only be used if the licensee wishes to including the

   600 	 * Dispatcher beneath their own SIM ATK TSY.

   601 	 * 

   602 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyServiceRequest

   603 	 * request from the CTSY.

   604 	 * 

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

   606 	 * CCtsyDispatcherCallback::CallbackSatRefreshAllowedComp()

   607 	 *

   608 	 * 

   609 	 * Implementation of this interface allows the main RSat clients report (RSat::RefreshAllowed()) 

   610 	 * if the refresh can be carried out to be passed to the LTSY.

   611 	 * The completion CCtsyDispatcherCallback::CallbackSatRefreshAllowedComp()

   612 	 * completes any outstanding RSat::NotifyRefreshPCmd() requests.

   613 	 * 

   614 	 *

   615 	 * @param aRefreshFileList The list of files (full path) that have been changed by the UICC (see ETSI 102 221 or ETSI 151 011)

   616 	 * @param aAid Indicates the application on the UICC to be refreshed (as defined ETSI TS 101 220) . 

   617 	 * @param aTsyCache Bit field of files that are cached in SIM ATK TSY (examin using CSatNotificationsTsy::TCachedSimAtkFiles) 

   618 	 * 

   619 	 * @see RSat::NotifyRefreshRequired()

   620 	 * @see RSat::RefreshAllowed()

   621 	 * @see RMmCustomAPI::SatRefreshCompleteNotification()

   622 	 *

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

   624 	 * failure.

   625 	 */

   626 	virtual TInt HandleRefreshAllowedReqL(const TDesC8& aRefreshFileList, const TDesC8& aAid, TUint16 aTsyCache) = 0;

   627 

   628 	}; // class MLtsyDispatchSatRefreshAllowed

   629 

   630 

   631 

   632 class MLtsyDispatchSatReady : public MLtsyDispatchInterface

   633 	{

   634 public:

   635 

   636 	static const TInt KLtsyDispatchSatReadyApiId = KDispatchSatFuncUnitId + 18;

   637 

   638 	/**

   639 	 * This API is optional and should only be used if the licensee wishes to including the

   640 	 * Dispatcher beneath their own SIM ATK TSY.

   641 	 * 

   642 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyReady

   643 	 * request from the CTSY.

   644 	 * 

   645 	 * Implementation of this interface allows the CTSY to signal that it is ready to receive proactive commands.

   646 	 *

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

   648 	 * failure.

   649 	 */

   650 	virtual TInt HandleReadyReqL() = 0;

   651 

   652 	}; // class MLtsyDispatchSatReady

   653 

   654 

   655 

   656 class MLtsyDispatchSatPCmdNotification : public MLtsyDispatchInterface

   657 	{

   658 public:

   659 

   660 	static const TInt KLtsyDispatchSatPCmdNotificationApiId = KDispatchSatFuncUnitId + 19;

   661 

   662 	/**

   663 	 * This API is optional and should only be used if the licensee wishes to including the

   664 	 * Dispatcher beneath their own SIM ATK TSY.

   665 	 * 

   666 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyGetIfPendingNotification

   667 	 * request from the CTSY.

   668 	 * 

   669 	 * It is a request call that does not have an associated complete callback.

   670 	 * 

   671 	 * This function uses this API to register an interest in a particular proactive command. Once this notification

   672 	 * has been set up, the LTSY should call CCtsyDispatcherCallback::CallbackSatPcmdInd() to notify the CTSY the next 

   673 	 * time this proactive command is generated by the UICC (or provide notification immediately if the command is pending).

   674 	 * 

   675 	 * Proactive commands which are received via CCtsyDispatcherCallback::CallbackSatPcmdInd() while a notification has not 

   676 	 * been requested for this proactive command then a Terminal Response containing the return code "KMeUnableProcessCmd" 

   677 	 * will be sent back to the UICC. Therfore it is perfectly acceptable for the LTSY to pass all proactive commands directly

   678 	 * to the CTSY if it is preferred to have CTSY process proactive commands. If the latter implementation is chosen, LTSY does 

   679 	 * not have to implement the MLtsyDispatchSatPCmdNotification interface at all. 

   680 	 * 

   681 	 * @param aPCmdType The number of the proactive command for which notification is being requested (e.g. KSetUpMenu),

   682 	 *  as defined in ETSI 102 223 etc. these are defined in bertlv_defs.h  

   683 	 *

   684 	 * @see bertlv_defs.h

   685 	 * 

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

   687 	 * failure.

   688 	 */

   689 	virtual TInt HandlePCmdNotificationReqL(TUint8 aPCmdType) = 0;

   690 

   691 	}; // class MLtsyDispatchSatPCmdNotification

   692 

   693 

   694 

   695 class MLtsyDispatchSatUssdControlEnvelopeError : public MLtsyDispatchInterface

   696 	{

   697 public:

   698 

   699 	static const TInt KLtsyDispatchSatUssdControlEnvelopeErrorApiId = KDispatchSatFuncUnitId + 20;

   700 

   701 	/**

   702 	 * This API is optional and should only be used if the licensee wishes to including the

   703 	 * Dispatcher beneath their own SIM ATK TSY.

   704 	 * 

   705 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyEnvelopeError

   706 	 * request from the CTSY.

   707 	 * 

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

   709 	 * CCtsyDispatcherCallback::CallbackSatGetUssdControlSupportedComp()

   710 	 * 

   711 	 * This interface is invoked if it has not been possible to construct an envelope for 

   712 	 * USSD control. This would occur if USSD strings are not supported for call control,

   713 	 * and the USSD control request cannot be submitted as an SS control request because it 

   714 	 * contains characters other than *, #, 0-9.

   715 	 * 

   716 	 * Implementation of this interface should handle this error appropriately (such as by

   717 	 * continuing the USSD setup process). 

   718 	 * 

   719 	 * @see MLtsyDispatchSatGetUssdControlSupported::HandleGetUssdControlSupportedReqL()

   720 	 *

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

   722 	 * failure.

   723 	 */

   724 	virtual TInt HandleUssdControlEnvelopeErrorReqL() = 0;

   725 

   726 	}; // class MLtsyDispatchSatUssdControlEnvelopeError

   727 

   728 

   729 

   730 class MLtsyDispatchSatTimerExpirationEnvelope : public MLtsyDispatchInterface

   731 	{

   732 public:

   733 

   734 	static const TInt KLtsyDispatchSatTimerExpirationEnvelopeApiId = KDispatchSatFuncUnitId + 21;

   735 

   736 	/**

   737 	 * This API is optional and should only be used if the licensee wishes to including the

   738 	 * Dispatcher beneath their own SIM ATK TSY.

   739 	 * 

   740 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyTimerExpiredIPC

   741 	 * request from the CTSY.

   742 	 * 

   743  	 * It is a request call that does not have an associated complete callback.

   744 	 * 

   745 	 * The Timer managment proactive command requests the terminal to manage timers 

   746 	 * running physically in the terminal.

   747 	 * 

   748 	 * When a timer expires (i.e. reaches zero), the terminal shall use the Timer Expiration 

   749 	 * mechanism to transfer the identifier of the timer that has expired and the difference 

   750 	 * between the time when this transfer occurs and the time when the timer was initially started. 

   751 	 * The terminal then deactivates the timer.

   752 	 * 

   753 	 * This handler passes to the LTSY the Timer expiration ENVELOPE command, when a timer 

   754 	 * previously started by a TIMER MANAGEMENT proactive command has expired.

   755 	 * 

   756 	 * Note that the command will not be sent until any proactive command is no longer ongoing.

   757 	 * (i.e. the Terminal responses completion (CCtsyDispatcherCallback::CallbackSatTerminalRspComp() )

   758 	 * to the proactive command has been completed by the LTSY) 

   759 	 *

   760 	 *

   761 	 * @param aEnvelope BER-TLV encoded Timer expiration ENVELOPE command

   762 	 * see "ETSI TS 102 223" under "ENVELOPE commands" "Timer expiration" 

   763 	 *

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

   765 	 * failure.

   766 	 */

   767 	virtual TInt HandleTimerExpirationEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   768 

   769 	}; // class MLtsyDispatchSatTimerExpirationEnvelope

   770 

   771 

   772 

   773 class MLtsyDispatchSatTerminalRsp : public MLtsyDispatchInterface

   774 	{

   775 public:

   776 

   777 	static const TInt KLtsyDispatchSatTerminalRspApiId = KDispatchSatFuncUnitId + 22;

   778 

   779 	/**

   780 	 * This API is optional and should only be used if the licensee wishes to including the

   781 	 * Dispatcher beneath their own SIM ATK TSY.

   782 	 * 

   783 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTerminalRsp

   784 	 * request from the CTSY.

   785 	 *

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

   787 	 * CCtsyDispatcherCallback::CallbackSatTerminalRspComp()

   788 	 *

   789 	 * Implementation of this interface should allow responses to Proactive Commands to be provided to the LTSY.

   790 	 *

   791 	 * @param aTerminalRsp The terminal response TLV as formatted in "ETSI TS 102 223" Under "Structure of TERMINAL RESPONSE" 

   792 	 *

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

   794 	 * failure.

   795 	 */

   796 	virtual TInt HandleTerminalRspReqL(const TDesC8& aTerminalRsp) = 0;

   797 

   798 	}; // class MLtsyDispatchSatTerminalRsp

   799 

   800 

   801 

   802 class MLtsyDispatchSatMenuSelectionEnvelope : public MLtsyDispatchInterface

   803 	{

   804 public:

   805  

   806 	static const TInt KLtsyDispatchSatMenuSelectionEnvelopeApiId = KDispatchSatFuncUnitId + 23;

   807 

   808 	/**

   809 	 * This API is optional and should only be used if the licensee wishes to including the

   810 	 * Dispatcher beneath their own SIM ATK TSY.

   811 	 * 

   812 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatMenuSelection

   813 	 * request from the CTSY.

   814 	 * 

   815 	 * It is a request call that does not have an associated complete callback.

   816 	 * 

   817 	 * When the SIM application has previously specified a menu to the ME via the SETUP MENU proactive

   818 	 * command, this API is used by the ME to communicate to the SIM application either that the user has 

   819 	 * selected one of the menu items, or that the user has requested help information for one of the 

   820 	 * menu items.

   821 	 *  

   822 	 *

   823 	 * @param aEnvelope BER-TLV encoded Envelope containing the identifier of a menu item and whether the 

   824 	 * user of the ME has selected the menu item or requested help about it. 

   825 	 *

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

   827 	 * failure.

   828 	 */

   829 	virtual TInt HandleMenuSelectionEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   830 

   831 	}; // class MLtsyDispatchSatMenuSelectionEnvelope

   832 

   833 

   834 

   835 class MLtsyDispatchSatEventDownloadEnvelope : public MLtsyDispatchInterface

   836 	{

   837 public:

   838 

   839 	static const TInt KLtsyDispatchSatEventDownloadEnvelopeApiId = KDispatchSatFuncUnitId + 24;

   840 

   841 	/**

   842 	 * This API is optional and should only be used if the licensee wishes to including the

   843 	 * Dispatcher beneath their own SIM ATK TSY.

   844 	 * 

   845 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatEventDownload

   846 	 * request from the CTSY.

   847 	 * 

   848 	 * It is a request call that does not have an associated complete callback.

   849 	 * 

   850 	 * The SET UP EVENT LIST proactive command gives the phone a list of events that may occur

   851 	 * to the phone.  The event list may include a change of access technology, user

   852 	 * action, browser termination and more.   The UICC must be informed when an event

   853 	 * on the list occurs - this is via  

   854 	 * MLtsyDispatchSatEventDownloadEnvelope::HandleEventDownloadEnvelopeReqL()

   855 	 *

   856 	 * @param aEnvelope BER-TLV encoded Event Download ENVELOPE command

   857 	 * see "ETSI TS 102 223" under "ENVELOPE commands" "Event Download" 

   858 	 *

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

   860 	 * failure.

   861 	 * 

   862 	 * @see RSat::EventDownload()

   863 	 */

   864 	virtual TInt HandleEventDownloadEnvelopeReqL(const TDesC8& aEnvelope) = 0;

   865 

   866 	}; // class MLtsyDispatchSatEventDownloadEnvelope

   867 

   868 

   869 class MLtsyDispatchSatGetUssdControlSupported : public MLtsyDispatchInterface

   870 	{

   871 public:

   872 	

   873 	static const TInt KLtsyDispatchSatGetUssdControlSupportedApiId = KDispatchSatFuncUnitId + 25;

   874 	

   875 	/**

   876 	 * This API is optional and should only be used if the licensee wishes to including the

   877 	 * Dispatcher beneath their own SIM ATK TSY.

   878 	 * 

   879 	 * The CTSY Dispatcher shall invoke this function on receiving the ESatTsyUssdControlSupported

   880 	 * request from the CTSY.

   881 	 * 

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

   883 	 * CCtsyDispatcherCallback::CallbackSatGetUssdControlSupportedComp()

   884 	 *

   885 	 * Asks whether USSD string data objects are supported in call control. This setting is 

   886 	 * stored in EF-SST - see ETSI 151 011 etc. If USSD control is not supported, USSD control 

   887 	 * requests that can be coded as an SS string (i.e. *,#,0-9) will be submitted in this format.  

   888 	 *

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

   890 	 * failure.

   891 	 */

   892 	virtual TInt HandleGetUssdControlSupportedReqL() = 0;

   893 	

   894 	}; //class MLtsyDispatchSatGetUssdControlSupported

   895 

   896 #endif /*MLTSYDISPATCHSATINTERFACE_H_*/