1 // Copyright (c) 2002-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 // ETel (U)SAT header file.

    15 // Describes the (U)SAT API - classes, methods and types.

    16 // 

    17 //

    18 

    19 /**

    20  @file

    21  @publishedPartner

    22  @released

    23 */

    24 

    25 

    26 #ifndef __ETELSAT_H__

    27 #define __ETELSAT_H__

    28 

    29 #include <e32base.h>

    30 #include <s32mem.h>

    31 #include <etel.h>

    32 

    33 const TInt KETelExtSatV1=5000;  //< The global identifier for the first version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    34 const TInt KETelExtSatV2=9000;  //< The global identifier for the second version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    35 const TInt KETelExtSatV3=11000; //< The global identifier for the third version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    36 const TInt KEtelExtSatV4=11100; //< The global identifier for the fourth version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    37 const TInt KEtelExtSatV5=11200;	//< The global identifier for the fifth version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    38 const TInt KEtelExtSatV6=11300;	//< The global identifier for the sixth version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    39 const TInt KEtelExtSatV7=11400;	//< The global identifier for the seventh version of the ETelSat API, for passing into RTelServer::IsSupportedByModule()

    40 

    41 /**

    42 (U)SAT allocated error space ranges from -5250 to -5299.

    43 Do not return KErrSatBase as an error.

    44 */

    45 const TInt KErrSatBase=-5250;

    46 /** The (U)SIM Application Toolkit is busy. */

    47 const TInt KErrSatBusy=KErrSatBase-1;

    48 /**

    49 The error code can be received following Call Control.  It is returned when the

    50 (U)SIM (or MO SM Control by (U)SIM) either bars or modifies the original

    51 action.

    52 */

    53 const TInt KErrSatControl=KErrSatBase-2;

    54 /**

    55 The error code can be received following Multimedia Service Notification Download.

    56 It is returned when the (U)SIM either bars the original action,The ME shall not retry the same command.

    57 */

    58 const TInt KErrSatMmsFailure=KErrSatBase-3;

    59 

    60 enum {KTpduMaxSize=248};

    61 typedef TBuf8<KTpduMaxSize> TTpdu;

    62 

    63 const TInt KPdpActivationParametersMaxLengh=512;  //< Global constant defines maximum length of the buffer that can hold PDP CONTEXT ACTIVATION REQUEST

    64 typedef TBuf8<KPdpActivationParametersMaxLengh> TPdpParameters;

    65 

    66 // Forward declaration

    67 class CSatPtrHolder;

    68 class RSat: public RTelSubSessionBase

    69 /**

    70  * Provides an interface to Symbian's ETelSat API.  RSat inherits from

    71  * RTelSubSessionBase defined in ETEL.H.

    72  *

    73  * On GSM/WCDMA networks, this API offers access to the (U)SIM Application

    74  * Toolkit, or (U)SAT.  On CDMA networks, it offers access to Cdma Card Application

    75  * Toolkit, or CCAT. Both toolkits are very similar.

    76  *

    77  * Phones on both networks contain an electronic card that stores the information

    78  * such as subscriber's identification, the phone's number, an address book, etc.

    79  * The (U)SAT and CCAT toolkits allow the card to be more than just a storage

    80  * device; they define a protocols that allow the card to ask the phone to perform

    81  * tasks.  For instance, a card can ask the phone to display a message on the

    82  * screen, add new menu items to the phone's menus, ask the phone to dial a number,

    83  * or browse to a URL.

    84  *

    85  * (U)SAT and CCAT are based around 'Proactive Commands': each is a task for the

    86  * phone to perform.  For the four tasks mentioned in the previous paragraph, the

    87  * card sends the phone proactive commands called DISPLAY TEXT, SET UP MENU, SET

    88  * UP CALL, and LAUNCH BROWSER. Understanding the range of proactive commands and

    89  * their capabilities is the first step to understanding (U)SAT and CCAT.

    90  *

    91  * To use Symbian's ETelSat API you request notification when proactive commands

    92  * arrive at the phone.  For each proactive command (DISPLAY TEXT, SET UP

    93  * MENU etc.) there is an RSat member function.  This function tells Symbian OS

    94  * when you are interested in a proactive command.  It also gives

    95  * Symbian OS a TRequestStatus that is completed when the next proactive

    96  * command arrives.

    97  *

    98  * Some of the proactive commands are not accessible to Symbian's ETelSat API.

    99  * Your phone's TSY deals with them for you, hiding them from RSat.  The remaining

   100  * proactive commands are handled by RSat.  Request notification for each one

   101  * using the functions listed below.

   102  *

   103  * (U)SAT and CCAT are defined in 3GPP TS 31.111 and 3GPP2 C.S0035-0 respectively.

   104  * Both of these specifications are based on ETSI TS 102 223.  We suggest you read

   105  * ETSI TS 102 223 before reading anything else: it is much more informative and

   106  * easier to read than the other two specifications. We also suggest you have a

   107  * basic understanding of ETSI TS 102 223 before using Symbian's ETelSat API.

   108  *

   109  * Before starting a (U)SAT or CCAT session, start a session with a phone.  A phone

   110  * session is represented by either RPhone or RMobilePhone.  Now you can create an

   111  * RSat interface and start the RSat session with RSat::Open().  Pass this method

   112  * the RPhone or RMobilePhone instance.  This tells the (U)SAT or CCAT session

   113  * which phone to work with.

   114  *

   115  * This documentation uses the word "UICC" to mean  the card. Here are

   116  * the phrases used to describe the card on various networks:

   117  *

   118  * On GSM networks, the physical card is called the ICC and the software it

   119  * contains is called the SIM (Subscriber Identity Module).  SAT is an interface

   120  * to the software.

   121  *

   122  * On WCDMA networks, the physical card is called the UICC and the software it

   123  * contains is called the USIM (Universal Subscriber Identity Module).  USAT is an

   124  * interface to the software.

   125  *

   126  * On 3G CDMA networks, the card and the software are called a R-UIM.  CCAT is an

   127  * interface to the software.

   128  *

   129  * To use the ETelSat API, follow these steps.  Firstly, create an interface to the phone, if you haven't already done so:

   130  *

   131  * - Create an RPhone

   132  * - Call RPhone::ConstructL()

   133  * - Call RPhone::Open()

   134  *

   135  * Secondly, create and open an interface to the ETelSat client:

   136  *

   137  * - Create an RSat

   138  * - Call RSat::ConstructL()

   139  * - Call RSat::Open(), passing it the RPhone from the previous step.

   140  *

   141  * Now tell the UICC what SAT features the phone supports.  The UICC expects this

   142  * information in a "profile" object.  The structure of this object is described in

   143  * ETSI TS 102 223.

   144  *

   145  * - Firsly, call RSat::GetMeSideSatProfile().  The TSY returns a profile

   146  * describing the SAT features that are supported by the phone's hardware and the

   147  * TSY.  These will be features that are not under the ETelSat client's control; you

   148  * cannot use the RSat API to access them.

   149  *

   150  * - Now modify the profile to include the SAT features that you support.  This

   151  * will mainly involve settings flags in the profile object.

   152  *

   153  * - Finally, send the profile to the UICC by calling RSat::ClientSatProfileIndication()

   154  *

   155  * Here is a list of the proactive commands supported by RSat.  Once you have

   156  * completed all the steps above, queue some notification requests by

   157  * calling some RSat::Notify..... command listed below:

   158  *

   159  * - DISPLAY TEXT - displays text to the user - see RSat::NotifyDisplayTextPCmd()

   160  * - GET INKEY -

   161  *   instructs phone to display text and/or an icon and to expect the user to enter a single character -

   162  *   RSat::NotifyGetInkeyPCmd()

   163  * - GET INPUT -

   164  *   instructs phone to display text and/or an icon and to expect the user to enter a string -

   165  *   RSat::NotifyGetInputPCmd()

   166  * - PLAY TONE -

   167  *   instructs phone to play a tone -

   168  *   RSat::NotifyPlayTonePCmd()

   169  * - SET UP MENU -

   170  *   provides a set of menu items to be integrated with the phone's menu system -

   171  *   RSat::NotifySetUpMenuPCmd()

   172  * - SELECT ITEM -

   173  *   provides a set of menu items to be shown to the user. The user can choose one of these menu items -

   174  *   RSat::NotifySelectItemPCmd()

   175  * - SEND SHORT MESSAGE -

   176  *   asks the phone to send an SMS message -

   177  *   RSat::NotifySendSmPCmd()

   178  * - SEND SS -

   179  *   asks the phone to send a supplementary service request -

   180  *   RSat::NotifySendSsPCmd()

   181  * - SEND USSD -

   182  *   asks the phone to send a Unstructured Supplementary Service Data request to the network -

   183  *   RSat::NotifySendUssdPCmd()

   184  * - SET UP CALL -

   185  *   asks the phone to connect a call -

   186  *   RSat::NotifySetUpCallPCmd()

   187  * - REFERSH -

   188  *   indicates that changes have occurred to the UICC that may affect the phone -

   189  *   RSat::NotifyRefreshPCmd()

   190  * - SET UP EVENT LIST -

   191  *   gives the phone a list of events that may occur to the phone.

   192  *   The phone must inform the UICC when an event on the list occurs -

   193  *   RSat::NotifySetUpEventListPCmd()

   194  * - SET UP IDLE MODE TEXT -

   195  *   provides text (and optionally an icon) to be displayed when the phone is idle -

   196  *   RSat::NotifySetUpIdleModeTextPCmd()

   197  * - SEND DTMF -

   198  *   asks the phone to send a DTMF string -

   199  *   RSat::NotifySendDtmfPCmd()

   200  * - PERFORM CARD APDU -

   201  *   asks the phone to send an APDU command -

   202  *   RSat::NotifyPerformCardApduPCmd()

   203  * - POWER OFF CARD -

   204  *   closes the session with the card specified in the command -

   205  *   RSat::NotifyPowerOffCardPCmd()

   206  * - POWER ON CARD -

   207  *   starts a session with the card specified in the command -

   208  *   RSat::NotifyPowerOnCardPCmd()

   209  * - GET READER STATUS -

   210  *   requests the status of the card reader specified in the command -

   211  *   RSat::NotifyGetReaderStatusPCmd()

   212  * - RUN AT COMMAND -

   213  *   asks the phone to perform the AT command provided -

   214  *   RSat::NotifyRunAtCommandPCmd()

   215  * - LANGUAGE NOTIFICATION -

   216  *   tells the phone the language in which any text strings from the UICC are written -

   217  *   RSat::NotifyLanguageNotificationPCmd()

   218  * - LAUNCH BROWSER -

   219  *   asks the phone to browse to the supplied URL -

   220  *   RSat::NotifyLaunchBrowserPCmd()

   221  * - OPEN CHANNEL -

   222  *   asks the phone to open a channel -

   223  *   RSat::NotifyOpenChannelPCmd()

   224  * - CLOSE CHANNEL -

   225  *   asks the phone to close a channel previously opened with the OPEN CHANNEL proactive command -

   226  *   RSat::NotifyCloseChannelPCmd()

   227  * - RECEIVE DATA -

   228  *   asks the phone for data from  a channel opened with the OPEN CHANNEL proactive command -

   229  *   RSat::NotifyReceiveDataPCmd()

   230  * - SEND DATA -

   231  *   asks the phone to send data on a channel opened with the OPEN CHANNEL proactive command -

   232  *   RSat::NotifySendDataPCmd()

   233  * - GET CHANNEL STATUS -

   234  *   asks the phone to return the status of a channel opened with the OPEN CHANNEL proactive command -

   235  *   RSat::NotifyGetChannelStatusPCmd()

   236  * - SERVICE SEARCH -

   237  *   RSat::NotifyServiceSearchPCmd()

   238  * - GET SERVICE INFO -

   239  *   RSat::NotifyGetServiceInfoPCmd()

   240  * - DECLARE SERVICE -

   241  *   RSat::NotifyDeclareServicePCmd()

   242  * - TIMER MANAGEMENT -

   243  *   asks the phone to start, stop and read the current value of timers -

   244  *   RSat::NotifyTimerMgmtPCmd()

   245  * - PROVIDE LOCAL INFORMATION -

   246  *   instructs the phone to send local information to the UICC -

   247  *   RSat::NotifyLocalInfoPCmd()

   248  * - POLLING INTERVAL -

   249  *   tells the phone how often the UICC would like to be polled by the phone -

   250  *   RSat::NotifyPollingIntervalPCmd()

   251  * - POLLING OFF -

   252  *   tells the phone not to poll the UICC for proactive commands any more -

   253  *   RSat::NotifyPollingOffPCmd()

   254  * - RETRIEVE MULTIMEDIA MESSAGE

   255  *   asks the phone to store the Multimedia Message received from the Network on UICC-

   256  *   RSat::NotifyRetrieveMultimediaMsgPCmd()

   257  * - SUBMIT MULTIMEDIA MESSAGE

   258  *   asks the phone to submit the Multimedia Message stored in the UICC to the Network-

   259  *   RSat::NotifySubmitMultimediaMsgPCmd()

   260  * - DISPLAY MULTIMEDIA MESSAGE

   261  *   asks the phone to display the Multimedia message to the user-

   262  *   RSat::NotifyDisplayMultimediaMsgPCmd() 

   263  * - SET FRAMES

   264  *   This command instructs the terminal to divide the terminal screen into multiple, scrollable rectangular regions called frames inorder to present multiple information at once-

   265  *   RSat::NotifySetFramesPCmd()

   266  * - GET FRAMES STATUS

   267  *   This command requests the terminal to return a Frames parameters data object-

   268  *   RSat::NotifyGetFramesStatusPCmd()

   269  *

   270  * Note: the phone continuously polls the card, waiting for proactive commands.

   271  * However, the polling process is hidden from the ETelSat API - simply request

   272  * notification and wait for the commands.

   273  */

   274     {

   275 public:

   276     IMPORT_C RSat();

   277     IMPORT_C TInt Open(RPhone& aPhone);

   278     IMPORT_C void Close();

   279     IMPORT_C void NotifyProactiveSimSessionEnd(TRequestStatus& aReqStatus) const;

   280     IMPORT_C void NotifyProactiveSimSessionStart(TRequestStatus& aReqStatus) const;

   281 

   282     class TSatBase

   283     /**

   284     Base class for all the (U)SAT ETel API parameters.

   285 

   286     There may be several versions of a parameter.  Parameter classes are named

   287     'name version number', such as RSat::TGetInkeyV1 and RSat::TGetInkeyV2.

   288     Both of these classes are used with the "GET INKEY" proactive command. They

   289     hold similar information but are designed for use with different versions

   290     of the (U)SAT ETel API. Version 2 contains the version 1 class plus extra

   291     information.  A third version would contain version 2 plus extra

   292     information, etc.

   293 

   294     In classes derived from RSat::TSatBase, the base class holds the class's

   295     version number.  The version number is a value from RSat::TSatVersion.

   296     Each value in RSat::TSatVersion describes the versions of Symbian OS with

   297     which they are used.

   298 

   299     You never need to set the version number; the class's constructor does

   300     this. Generally, RSat clients do not need to read the version number.

   301 

   302     The TSY can use RSat::TSatBase::ExtensionId() to return the version number.

   303     A typical situation is this:  the TSY is passed a (U)SAT ETel API parameter

   304     in a descriptor.  The TSY does not know which version it has been given so

   305     it should guess. For example, it could unpack the descriptor into the

   306     latest version of the parameter then call RSat::TSatBase::ExtensionId() to

   307     retrieve the actual version number.  If the TSY chose the incorrect version

   308     number then the descriptor can be unpacked into the correct parameter class.

   309     */

   310         {

   311     public:

   312         IMPORT_C TInt ExtensionId() const;

   313     protected:

   314         TSatBase();

   315     protected:

   316         /** The extension identifier or version number. */

   317         TInt iExtensionId;

   318         };

   319 

   320 

   321     class TSatPCmdBase : public TSatBase

   322     /**

   323     Base class for all the (U)SAT ETel API proactive command classes.

   324 

   325     TSatPCmdBase inherits from TSatBase and is the base class for all the (U)SAT

   326     ETel API proactive command classes, for which it holds the associated

   327     proactive command number.

   328     */

   329         {

   330     public:

   331         IMPORT_C TUint8 PCmdNumber() const;

   332         IMPORT_C TInt SetPCmdNumber(TUint8 aNumber);

   333     protected:

   334         TSatPCmdBase();

   335     protected:

   336         /** Proactive command number from 3GPP 31.111 and ETSI TS 102 223.

   337         Valid range is 0x01 to 0xFE. */

   338         TUint8 iPCmdNumber;

   339         };

   340 

   341     enum TSatVersion

   342     /**

   343     The version number of a (U)SAT ETel API parameter,

   344     returned by RSat::TSatBase::ExtensionId().

   345     @see RSat::TSatBase

   346     */

   347         {

   348         KSatVersionNotSet=-1,   //< (U)SAT version has not been set yet

   349         KSatV1=1,               //< API version 1, (U)SAT API delivered by v6.1 and v7.0.

   350         KSatV2=2,               //< API version 2, (U)SAT API delivered by 7.0s

   351         KSatV3=3,               //< API version 3, (U)SAT API delivered by v8.0a, v8.0b, v8.1a, v8.1b.

   352    		KSatV4=4,				//< API version 4, (U)SAT API delivered by v9.1

   353         KSatV5=5,				//< API version 5, (U)SAT API delivered by v9.2

   354         KSatV6=6,				//< API version 6, (U)SAT API delivered by v9.4

   355         KSatV7=7				//< API version 7, (U)SAT API delivered by v9.5

   356         };

   357 

   358     enum THelp

   359     /**

   360     The UICC may offer help to accompany a GET INKEY, GET INPUT, SET UP MENU or

   361     SELECT ITEM proactive command. This help is normally text for the phone's

   362     user.

   363 

   364     Below are links to four member functions.  They request notification for

   365     the GET INKEY, GET INPUT, SET UP MENU or SELECT ITEM proactive commands.

   366     When they complete, an object is returned containing the proactive

   367     command's details.  This includes an RSat::THelp that states whether help

   368     is available for the command.

   369 

   370     It is up to you whether you tell the user that help is available, and

   371     whether to display the help should the user ask for it. The proactive

   372     command does not contain the help; it only indicates whether help is

   373     available with RSat::THelp.  The process of getting help depends upon the

   374     proactive command; see the links to the member functions below for details.

   375 

   376     @see RSat::NotifyGetInkeyPCmd()

   377     @see RSat::NotifyGetInputPCmd()

   378     @see RSat::NotifySetUpMenuPCmd()

   379     @see RSat::NotifySelectItemPCmd()

   380     */

   381         {

   382         EHelpNotSet,        //< Initialization value used within constructor(s).

   383         EHelpAvailable,    //< Help information available to the user.

   384         ENoHelpAvailable    //< No help information is available to the user.

   385         };

   386 

   387     enum TTimeUnit

   388     /**

   389     Describes the units in RSat::TDuration.

   390     @see RSat::TDuration

   391     */

   392         {

   393         ETimeUnitNotSet,    //< Initialization value used within constructor(s).

   394         ENoDurationAvailable,     //< No duration has been provided. The ME should default to general beep.

   395         EMinutes,    //< The duration is expressed in minutes.

   396         ESeconds,     //< The duration is expressed in seconds.

   397         ETenthsOfSeconds    //< The duration is expressed in tenths of seconds.

   398         };

   399 

   400     struct TDuration

   401     /** Class used in RSat whenever a measure of duration is required. */

   402         {

   403         TTimeUnit iTimeUnit;    //< Unit used to encode the duration in iNumOfUnits

   404         TUint8 iNumOfUnits;     //< Valid range is 1 to 255.

   405         };

   406 

   407     enum TDeviceId

   408     /** Some proactive commands are aimed at particular devices.  The device will be on of those defined here. */

   409         {

   410         KDeviceIdNotSet         =-1,      //< Initialisation value

   411         KKeypad                 =0x01,    //< The destination device for the proactive command is the keypad.

   412         KDisplay                =0x02,    //< The destination device for the proactive command is the display.

   413         KEarPiece               =0x03,    //< The destination device for the proactive command is the earpiece.

   414         KAdditionalCardReader0  =0x10,    //< The destination device for the proactive command is the additional card reader 0.

   415         KAdditionalCardReader1  =0x11,    //< The destination device for the proactive command is the additional card reader 1.

   416         KAdditionalCardReader2  =0x12,    //< The destination device for the proactive command is the additional card reader 2.

   417         KAdditionalCardReader3  =0x13,    //< The destination device for the proactive command is the additional card reader 3.

   418         KAdditionalCardReader4  =0x14,    //< The destination device for the proactive command is the additional card reader 4.

   419         KAdditionalCardReader5  =0x15,    //< The destination device for the proactive command is the additional card reader 5.

   420         KAdditionalCardReader6  =0x16,    //< The destination device for the proactive command is the additional card reader 6.

   421         KAdditionalCardReader7  =0x17,    //< The destination device for the proactive command is the additional card reader 7.

   422         KChannel1               =0x21,    //< The destination device for the proactive command is the channel 1.

   423         KChannel2               =0x22,    //< The destination device for the proactive command is the channel 2.

   424         KChannel3               =0x23,    //< The destination device for the proactive command is the channel 3.

   425         KChannel4               =0x24,    //< The destination device for the proactive command is the channel 4.

   426         KChannel5               =0x25,    //< The destination device for the proactive command is the channel 5.

   427         KChannel6               =0x26,    //< The destination device for the proactive command is the channel 6.

   428         KChannel7               =0x27,    //< The destination device for the proactive command is the channel 7.

   429         KUICC                   =0x81,    //< The destination device for the proactive command is the UICC.

   430         KME                     =0x82,    //< The destination device for the proactive command is the Mobile Equipment, typically a phone.

   431         KNetwork                =0x83     //< The destination device for the proactive command is the network.

   432         };

   433 

   434 	/**

   435 	Specifies the text coding scheme for RSat buffers. It may be used in

   436 	conjunction with any RSat buffer to indicate the coding scheme used.

   437 	(See ETSI TS 102 223 V5.9.0 section 8.15.)

   438 	*/

   439 	enum TSatTextCoding

   440 		{

   441 		/** 7-bit packed coding */

   442 		E7bitPacked,

   443 		/** 7-bit unpacked (i.e. 8-bit) coding */

   444 		E7bitUnpacked,

   445 		/** 16-bit Unicode (UCS-2) coding */

   446 		E16bitUCS2

   447 		};

   448 

   449 	/**

   450 	@see RSat::TTextString

   451 	*/

   452 	enum {KTextStringMaxSize=250};

   453 

   454     /** Generic Text String

   455 

   456     This text string definition is to be used through the API where a text

   457     string is required. Text string should be presented to the client in

   458     unicode format. This type can be used in envelope commands, proactive

   459     commands and terminal response.

   460     @see RSat::KTextStringMaxSize

   461     */

   462     typedef TBuf<KTextStringMaxSize> TTextString;

   463 

   464 

   465     // Alpha Identifier

   466 

   467     /**

   468     @see RSat::TAlphaIdBuf

   469     @see RSat::TAlphaId

   470 

   471 	@see RMobileCall::KAlphaIdMaxSize

   472 	*/

   473     enum {KAlphaIdMaxSize=254};

   474 

   475     /**

   476     Buffer containing the alpha identifier in the proactive command sent from the ICC.

   477 

   478 	@see RSat::TAlphaId

   479 

   480 	@see RMobileCall::TAlphaIdBuf

   481     */

   482     typedef TBuf<KAlphaIdMaxSize> TAlphaIdBuf;

   483 

   484     /**

   485     Indicates the status of the alpha ID to the client.  It can be present or

   486     not present.  If it is present, then it can contain data (typically text)

   487     or it can be a null object.

   488     @see RSat::TAlphaId

   489     */

   490     enum TAlphaIdStatus

   491         {

   492         EAlphaIdNotSet,     //< Value used at initialisation

   493         EAlphaIdProvided,   //< The alpha ID was provided by the ICC and contains data, typically text.

   494         EAlphaIdNull,       //< The alpha ID was provided by the ICC but was a null object.

   495         EAlphaIdNotPresent  //< No alpha ID provided by the ICC.

   496         };

   497 

   498     /**

   499     Proactive commands can include some text called an 'alpha identifier'.

   500     The meaning of the text depends upon the proactive command; see each

   501     command's description for more details.

   502 

   503     In Symbian OS, details of each proactive command are encapsulated in a

   504     class.  Each class includes an RSat::TAlphaId.  Inside this, iStatus

   505     contains the status of the command's alpha identifier:

   506 

   507     If iStatus is RSat::EAlphaIdProvided then RSat::TAlphaId::iAlphaId contains

   508     the proactive command's alpha identifier text.  The description of each

   509     proactive command will tell you what to do with the text.

   510 

   511     If iStatus is RSat::EAlphaIdNull then the proactive command's alpha

   512     identifier is an empty string.  RSat::TAlphaId::iAlphaId contains nothing.

   513     This commonly indicates that nothing should be display to the user while

   514     the proactive command is executed; see the proactive command's description.

   515 

   516     If iStatus is RSat::EAlphaIdNotPresent then the proactive command did not

   517     contain an alpha identifier.  This is commonly indicates that you can

   518     display whatever you like to the user while the proactive command is

   519     executed; see the proactive command's description.

   520 

   521     It is intended by ETSI / 3GPP to be a short identifier of one or two words.

   522     However the maximum buffer size is 254 in this API.

   523     */

   524     struct TAlphaId

   525         {

   526         TAlphaIdStatus iStatus; //< The status of the alpha ID.

   527         TAlphaIdBuf iAlphaId; 	//< The alpha ID's text.  Only valid if iStatus is RSat::EAlphaIdProvided.

   528         };

   529 

   530 	/** 

   531 	Size in bytes of a text attribute as defined in spec. ETSI TS 102 223 

   532 	@see RSat::TTextAttributeBuf

   533 	*/

   534 	enum {KTextAttributeBufSize=4};

   535 

   536 	/** Contains text attribute data. A text attribute contains

   537 	formatting information such as whether the text it is applied to

   538 	is bold, underlined, aligned left, etc. The text to which the

   539 	text attribute applies to depends on the specific proactive

   540 	UICC command and is specified in ETSI TS 102 223.

   541 	@see RSat::TTextAttribute

   542 	*/

   543 	typedef TBuf8<KTextAttributeBufSize> TTextAttributeBuf;

   544 

   545 	enum TTextAttributeStatus

   546 	/** Indicates the status of the text attribute to the client.

   547 	It can be present or not present.  If it is present, then it will

   548 	provide text attribute data.	This data is valid only if the

   549 	text to which the text attribute data applies to is also valid.

   550 	The text to which the text attribute applies to depends on the

   551 	specific proactive UICC command and is specified in ETSI TS 102 223.

   552 	@see RSat::TTextAttribute

   553 	*/

   554 		{

   555 		ETextAttributeNotSet,		 	//< Value used at initialisation

   556 		ETextAttributeProvided,			//< The text attribute was provided by the ICC and contains data.

   557 		ETextAttributeNotPresent		//< No text attribute provided by the ICC.

   558 		};

   559 

   560 	/**

   561 	Proactive commands which contain text may also contain formatting

   562 	information, called text attributes, which apply to the text

   563 	when it is displayed by the ME. If a Terminal receives a text

   564 	attribute that it does not support then it shall use the default

   565 	text attribute it supports.

   566 

   567 	For some proactive commands, the text attribute information

   568 	is a conditional parameter. This means it is only present in the

   569 	command if the text to which it applies is present as the text

   570 	itself is an optional part of the command.

   571 	For other proactive commands that always contain some text such

   572 	as an alpha identifier, the text attribute information is optional,

   573 	and can be present or not present.

   574 

   575 	The actual text to which the text attribute applies to depends on

   576 	the specific proactive UICC command and is specified in

   577 	ETSI TS 102 223.

   578 

   579 	The TTextAttribute structure is present in RSat classes which

   580 	represent proactive commands that support text attributes. The

   581 	structure contains iStatus which represents the status of

   582 	iTextAttribute.

   583 

   584 	If the iStatus is RSat::ETextAttributeNotPresent then no text

   585 	attribute data was supplied in the command. This commonly

   586 	indicates that the default formatting should be applied to

   587 	the text when it is displayed by the ME.

   588 

   589 	If the iStatis is RSat::ETextAttributeProvided then text

   590 	attribute data was supplied in the command.	This means that

   591 	the supplied formatting should be applied when the text to which

   592 	it applies is displayed on the ME.	If the supplied formatting

   593 	is not supported by the terminal, then default formatting should

   594 	be applied.

   595 	*/

   596 	struct TTextAttribute

   597 		{

   598 		/**

   599 		The status of the text attribute.  

   600 		@see RSat::TTextAttributeStatus

   601 		*/

   602 		TTextAttributeStatus iStatus;	  		

   603 		/**

   604 		The text attribute data. Only valid if the iStatus is 

   605 		RSat::ETextAttributeProvided and the text to which it applies is valid.  

   606 		@see RSat::TTextAttributeBuf

   607 		*/

   608 		TTextAttributeBuf iTextAttributeData;

   609 		};

   610 

   611 	/**

   612 	@see RSat::TCcp

   613 	

   614 	@see RMobileCall::KCcpMaxSize

   615 	*/

   616     enum {KCcpMaxSize=14}; 

   617 

   618     /**

   619     TCcp ( Capability configuration parameters ) is a 8-bit data buffer that

   620     contains the bearer capabilities as coded in ETSI 11.11 and ETSI 04.08. It

   621     is 14 bytes as it does not include the IEI (Information Element Identity).

   622 

   623     It is used by the SET UP CALL proactive command.  It is also used in call control.

   624 

   625     @see RSat::NotifySetUpCallPCmd()

   626     @see RSat::NotifyCallControlRequest()

   627     

   628     @see RMobileCall::TCcp

   629     */

   630     typedef TBuf8<KCcpMaxSize> TCcp;

   631 

   632 	/**

   633 	@see RSat::TSubAddress

   634 	

   635 	@see RMobileCall::KSubAddressMaxSize

   636 	*/

   637     enum {KSubAddressMaxSize=21};

   638 

   639     /**

   640     Sub-address of a telephone number. Maximum size is 21 digits.

   641 

   642     It is used by the SET UP CALL and OPEN CHANNEL proactive commands. It is

   643     also used in call control.

   644 

   645     @see RSat::NotifySetUpCallPCmd()

   646     @see RSat::NotifyCallControlRequest()

   647     @see RSat::NotifyOpenChannelPCmd()

   648     

   649     @see RMobileCall::TSubAddress

   650     */

   651     typedef TBuf<KSubAddressMaxSize> TSubAddress;

   652 

   653     /**

   654     Type of number, part of a complete telephone number address along with the

   655     numbering plan and the number's digits.

   656 

   657     @see RSat::TAddress

   658     @see RSat::TSsString

   659     */

   660     enum  TTypeOfNumber

   661         {

   662         ETypeOfNumberNotSet,    //< Initialization value used within constructor(s).

   663         EUnknownNumber,         //< The user or the network has no knowledge of the type of network.

   664         EInternationalNumber,   //< International number.

   665         ENationalNumber,        //< National number.

   666 

   667         /** Administration/service number specific to the serving network, e.g.

   668         used to access an operator.*/

   669         ENetworkSpecificNumber,

   670 

   671         /** Called dedicated access / short code in GSM/WCDMA. Corresponds to

   672         TMobileTON::ESubscriberNumber in ETel MM API. */

   673         EDedicatedNumber,

   674 

   675         EAlphanumericNumber,    //< Alphanumeric number.

   676         EAbbreviatedNumber      //< Abbreviated number.

   677         };

   678 

   679     /**

   680     Numbering plan, part of a complete telephone number

   681     address along with the type of number and the number's

   682     digits.

   683 

   684     @see RSat::TAddress

   685     @see RSat::TSsString

   686     */

   687     enum TNumberingPlan

   688         {

   689         ENumberingPlanNotSet,          //< Initialization value used within constructor(s).

   690         EUnknownNumberingPlan,         //< The user or the network has no knowledge of the numbering plan.

   691         EIsdnNumberPlan,               //< ISDN / telephony numbering plan.

   692         EDataNumberPlan,               //< Data numbering plan.

   693         ETelexNumberPlan,              //< Telex numbering plan.

   694 

   695         /** The service centre specific plan is used to indicate a numbering

   696         plan specific to External Short Message Entities attached to the SMS

   697         centre.*/

   698         EServiceCentreSpecificPlan1,

   699 

   700         /** The service centre specific plan is used to indicate a numbering

   701         plan specific to External Short Message Entities attached to the SMS

   702         centre. */

   703         EServiceCentreSpecificPlan2,

   704 

   705         ENationalNumberPlan,           //< National numbering plan.

   706         EPrivateNumberPlan,            //< Private numbering plan.

   707         EERMESNumberPlan               //< ERMES numbering plan.

   708         };

   709 

   710 	/**

   711 	@see RSat::TSatTelNumber

   712 	*/

   713     enum {KMaxMobileTelNumberSize=251};

   714 

   715     /**

   716     The phone number’s digits and other valid dial-string characters, coded as

   717     Unicode characters. RSat::TSatTelNumber is part of a complete telephone

   718     number address, along with the type of number and the numbering plan.

   719 

   720     Maximum size is 251 digits.

   721     @see RSat::TAddress

   722     */

   723     typedef TBuf<KMaxMobileTelNumberSize> TSatTelNumber;

   724 

   725     /**

   726     A complete telephone number.

   727     */

   728     struct TAddress

   729         {

   730         TTypeOfNumber iTypeOfNumber;    //< Type of number

   731         TNumberingPlan iNumberPlan;     //< Numbering plan

   732         TSatTelNumber iTelNumber;       //< Telephone number

   733         };

   734 

   735     /** 

   736      The originator of a call.

   737      

   738      This list of enumerations matches RMobileCall::TCallParamOrigin in Etelmm.

   739      

   740      @see RMobileCall::TCallParamOrigin

   741     */

   742     enum TCallParamOrigin

   743         {

   744         EOriginatorUnknown,       //< The call originator is unknown.

   745         EOriginatorSIM,           //< The call originated/originates from the SIM.

   746         EOriginatorEtelClient,    //< The call originated/originates from an Etel Client.

   747         EOriginatorExternal       //< The call originated/originates from an external device connected to the modem.

   748         }; 

   749         

   750         

   751     /** Maximum size of a SS or a USSD string

   752     @see RSat::TSsString

   753     @see RSat::TUssdString */

   754     enum {KStringMaxSize=242};

   755 

   756     struct TSsString

   757     /** A Supplementary Service string. */

   758         {

   759         TTypeOfNumber iTypeOfNumber;    //< Type of number

   760         TNumberingPlan iNumberPlan;     //< Numbering plan

   761         TBuf8<KStringMaxSize> iSsString;//< SS string. Max. length is 242 characters.

   762         };

   763 

   764     struct TUssdString

   765     /** An Unstructured Supplementary Services Data string. */

   766         {

   767         TUint8 iDcs;                        //< Data Coding Scheme

   768         TBuf<KStringMaxSize> iUssdString;   //< USSD string. Max. length is 242 characters.

   769         };

   770 

   771     enum TIconQualifier

   772     /** Included in each type of proactive command that can support icons.  It

   773     describes the icon, if there is one.

   774     

   775     @see RSat::TIconId

   776     @see RMobileCall::TIconQualifier

   777     */

   778         {

   779         EIconQualifierNotSet,   //< Icon qualifier is not set

   780         ENoIconId,              //< Icon not present in this proactive command.

   781         ESelfExplanatory,       //< Icon is included in the proactive command.  It is self explanatory. Display instead of the alpha ID or text string.

   782         ENotSelfExplanatory     //< Icon is included in the proactive command.  It is not self explanatory. Display both the icon and the alpha ID or text string.

   783         };

   784 

   785     struct TIconId

   786     /**

   787     Some types of proactive command can include an icon identifier. Commands

   788     that can include an icon will have an RSat::TIconId field. Icons are

   789     intended to provide graphical information to the user, although the display

   790     of icons is optional.

   791 

   792     If RSat::TIconId::iQualifier is RSat::ENoIconId then the proactive command

   793     does not provide an icon.

   794 

   795     Otherwise, an icon is provided.  The alpha identifier or text string in the

   796     proactive command will be present and will not be a null string.

   797 

   798     - If RSat::TIconId.iQualifier is RSat::ESelfExplanatory then the icon should

   799     be displayed instead of the alpha identifier or text string.

   800 

   801     - If RSat::TIconId.iQualifier is RSat::ENotSelfExplanatory then both icon

   802     and the alpha identifier or text string should be displayed.    If you are

   803     not able to display both (such as when the screen is too small) then

   804     display just the alpha identifier or text string.

   805 

   806     RSat::TIconId does not contain the icon itself.  Instead it contains an

   807     icon identifier, RSat::TIconId::iIdentifier.  Use RSat::GetIcon() followed

   808     by RSat::GetImageInstance() to get the icon from the UICC.

   809 

   810     There are two error cases related to icons:

   811 

   812     - If the UICC provides an icon identifier with a proactive command but

   813     you cannot display the icon for any reason, then inform the UICC by sending

   814     the general result "Command performed successfully, but requested icon

   815     could not be displayed"; see RSat::KSuccessRequestedIconNotDisplayed.

   816 

   817     - If you receive an icon, and either an empty or no alpha identifier/text

   818     string is given by the UICC, than reject the command with general result

   819     "Command data not understood by terminal"; see RSat::KCmdDataNotUnderstood.

   820 

   821     @see RSat::GetIcon()

   822     @see RSat::GetImageInstance()

   823     

   824     @see RMobileCall::TIconId

   825     */

   826         {

   827         /** Describes the state of the icon. */

   828         TIconQualifier iQualifier;

   829         /** Icon identifier, addresses a record in EF IMG. */

   830         TUint8 iIdentifier;

   831         };

   832 

   833     //

   834     // Read Icon

   835     //

   836     enum {KImageInstanceDescriptorsMaxSize=255}; //< @see RSat::TIcon

   837 

   838     /** RSat::GetIcon()  stores the an icon's EF record in this buffer. The

   839     record's structure is defined in ETSI TS 131 102; search for EFimg or

   840     "Contents of files at the DFGRAPHICS level"

   841     @see RSat::GetIcon()

   842     @see RSat::TIconId

   843     */

   844     typedef TBuf8<KImageInstanceDescriptorsMaxSize> TIcon;

   845 

   846     IMPORT_C void GetIcon(TRequestStatus& aReqStatus, TUint8 aRecordNumber, TIcon& aIconEf) const;

   847     IMPORT_C void GetImageInstance(TRequestStatus& aReqStatus, const TDesC8& aInstanceInfo, TDes8& aInstance) const;

   848 

   849     class TInstanceInfoV2 : public TSatPCmdBase

   850     /**

   851     Describes the exact position of a record within a EF IMG hold instance descriptor.

   852     RSat::TInstanceInfoV2 is packaged into a descriptor, RSat::TInstanceInfoV2Pckg.

   853     @see RSat::GetImageInstance()

   854     */

   855         {

   856     public:

   857         IMPORT_C TInstanceInfoV2();

   858     public:

   859         TUint iInstanceNumber;  //< The requested image instance EF.

   860         TUint16 iOffset;        //< The offset of the requested image instance EF.

   861         TUint16 iLength;        //< The length of the requested image instance EF in bytes.

   862         };

   863 

   864     /** A packaged RSat::TInstanceInfoV2. */

   865     typedef TPckg<TInstanceInfoV2>  TInstanceInfoV2Pckg;

   866 

   867     enum TImageCoding

   868     /** Coding used for icons.

   869     @see RSat::TInstanceInfoV3. */

   870     {

   871     KBasic             =0x11,   //< Basic Image Coding

   872     KColour            =0x21    //< Colour Image Coding

   873     };

   874 

   875     class TInstanceInfoV3 : public TInstanceInfoV2

   876     /**

   877     Describes the exact position, coding, size and File ID of a record within a

   878     EF IMG hold instance descriptor.

   879 

   880     The EF record is described in ETSI TS 131 102; search for EFimg or "Contents

   881     of files at the DFGRAPHICS level"

   882 

   883     To retrieve an image's data from the UICC, create an instance of this class

   884     and fill in fields with data retrieved with RSat::GetIcon().  Then pass the

   885     packaged version of this class (RSat::TInstanceInfoV3Pckg) to

   886     RSat::GetImageInstance().

   887 

   888     @see RSat::GetImageInstance()

   889     */

   890         {

   891     public:

   892         IMPORT_C TInstanceInfoV3();

   893     public:

   894         /**Image Coding Scheme*/

   895         TImageCoding iCoding;

   896         /**Image Width*/

   897         TUint8  iImgWidth;

   898         /**Image Height*/

   899         TUint8  iImgHeight;

   900         /**Image Instance File Identifier*/

   901         TUint16 iFileId;

   902         };

   903 

   904     /** A packaged RSat::TInstanceInfoV3. */

   905     typedef TPckg<TInstanceInfoV3>  TInstanceInfoV3Pckg;

   906 

   907     // API/TSY internal type

   908     struct TInstanceNumberAndOffset

   909         {

   910         TUint iInstanceNumber;  //< Image instance number

   911         TUint iOffset;          //< Image instance offset within the image record

   912         };

   913 

   914     IMPORT_C void GetClut(TRequestStatus& aReqStatus, TUint aInstanceNumber, TUint aOffset, TDes8& aClut) const;

   915 

   916     //

   917     // Terminal Response - Answer from the client to a proactive command

   918     //

   919 

   920     /** General Result of a proactive command.

   921 

   922     All proactive commands require a response from you to the UICC via the

   923     RSat::TerminalRsp() method.  When you send a response, include a value from

   924     this enumeration to indicate the level of success or failure. Some of these

   925     values require additional information to be returned to the UICC, too.  For

   926     instance, you cannot return just RSat::KMeUnableToProcessCmd, you must

   927     return a value from RSat::TMeProblem, too.  The description of each

   928     proactive command in 3GPP 31.111 and ETSI TS 102 223 will tell you what you

   929     need to return.

   930 

   931     The values KSuccess to KUssdTransactionTerminatedByUser indicate that the

   932     proactive command was successful.  It can be either completely or partially

   933     successful.

   934 

   935     The values from KMeUnableToProcessCmd to KLaunchBrowserError indicate

   936     temporary errors.  The UICC may make another attempt by resending the

   937     proactive command.

   938 

   939     The values from KCmdBeyondMeCapabilities onwards are permanent errors.  Use

   940     them to tell the UICC that the command cannot be executed at all.

   941 

   942     TPCmdResult enum values are dictated by 3GPP 31.111 and ETSI TS 102 223;

   943     see the description of the 'Result' data object.

   944     */

   945     enum TPCmdResult

   946         {

   947         KPCmdResultNotSet                       =-1,

   948 

   949         // ------------------

   950         // Successful results

   951         // ------------------

   952 

   953         /** Command performed successfully. There were no problems. */

   954         KSuccess                                =0x00,

   955 

   956         /** Command performed with partial comprehension; see 'Command results'

   957         in ETSI TS 102 223. */

   958         KPartialComprehension                   =0x01,

   959 

   960         /** Command performed, with missing information. Use when you received

   961         a minimum set of components but you believe some components to be

   962         missing. */

   963         KMissingInformation                     =0x02,

   964 

   965         /** REFRESH performed with additional EFs read. */

   966         KRefreshAdditionEFRead                  =0x03,

   967 

   968         /** Command performed successfully but requested icon could not be displayed. */

   969         KSuccessRequestedIconNotDisplayed       =0x04,

   970 

   971         /** Command performed, but modified by call control. Use this to

   972         indicate that call control modified the type of request indicated in

   973         the proactive command, and that the action requested by call control

   974         was performed successfully. */

   975         KModifiedByCallControl                  =0x05,

   976 

   977         /** Command performed successfully, limited service. */

   978         KSuccessLimitedService                  =0x06,

   979 

   980         /** Command performed with modification. Use this to indicate that you

   981         were unable to process the command using the exact parameters provided,

   982         but the command was processed with the best possible parameters.*/

   983         KPerformedWithModifications             =0x07,

   984 

   985         /** REFRESH performed but either the (U)SIM or R-UIM was not active. */

   986         KRefreshUSIMNotActive                   =0x08,

   987 

   988         /** PLAY TONE command performed successfully. */

   989 		KPlayTonePerformedSuccessfully		=0x09,

   990 

   991         /** (U)SAT / CCAT session terminated by the user. */

   992         KPSessionTerminatedByUser               =0x10,

   993 

   994         /** Backward move in the (U)SAT / CCAT  session requested by the user. */

   995         KBackwardModeRequestedByUser            =0x11,

   996 

   997         /** No response from user. */

   998         KNoResponseFromUser                     =0x12,

   999 

  1000         /** Help information required by the user.

  1001 

  1002         The UICC may offer help to accompany a GET INKEY, GET INPUT, SET UP

  1003         MENU or SELECT ITEM proactive command. This help is normally text for

  1004         the phone's user. If you tell the user that help is available, and if

  1005         they would like the help, then respond with this value.

  1006 

  1007         @see RSat::THelp */

  1008         KHelpRequestedByUser                    =0x13,

  1009 

  1010         /** USSD (Unstructured Supplementary Services Data) session terminated

  1011         by the user. */

  1012         KUssdTransactionTerminatedByUser        =0x14,

  1013 

  1014         // ----------------

  1015         // Temporary faults

  1016         // ----------------

  1017 

  1018         /** The phone is currently unable to process command.

  1019 

  1020         Besides returning this value, you must return additional information.

  1021         Return a value from RSat::TMeProblem and set the additional information

  1022         type to RSat::KMeProblem. */

  1023         KMeUnableToProcessCmd                   =0x20,

  1024 

  1025         /** The network is currently unable to process the command.

  1026 

  1027         The network will return a cause value to indicate the problem. These

  1028         values are defined in the appendices of 3GPP TS 24.008.  Set bit 8 of

  1029         the 8-bit code to 1, then include this code in the 'additional

  1030         information' field in your response to the UICC. Set the additional

  1031         information type to RSat::KSatNetworkErrorInfo.

  1032 

  1033         If no cause code is available, set the 'additional information' field to zero.*/

  1034         KNetworkUnableToProcessCmd              =0x21,

  1035 

  1036         /** In some proactive commands, you are required to solicit and receive

  1037         the user's approval before executing the proactive command. If the user

  1038         does not give approval then you should not execute it, and you should

  1039         give this response to the UICC. */

  1040         KPCmdNotAcceptedByUser                  =0x22,

  1041 

  1042         /** The user cleared down the call before the call

  1043         connected or before the network released the call. */

  1044         KCallClearedBeforeConnectionOrReleased  =0x23,

  1045 

  1046         /** Use this code when the UICC requests an action for a timer to be

  1047         taken by the terminal and the state of the timer does not allow that

  1048         action. */

  1049         KContradictionWithTimerState            =0x24,

  1050 

  1051         /** Use this to indicate that call control modified

  1052         the type of request indicated in the proactive command, and that the

  1053         action requested by call control encounters a temporary problem. */

  1054         KInteractionWithCCTemporaryError        =0x25,

  1055 

  1056         /** Error launching the browser.

  1057 

  1058         Besides returning this value, you must return an additional value

  1059         from RSat::TBrowserError. Set the additional information

  1060         type to RSat::KMeProblem. */

  1061         KLaunchBrowserError                     =0x26,

  1062 

  1063         /** The ME has rejected a RETRIEVE/SUBMIT/DISPLAY MUTIMEDIA MESSAGE 

  1064         proactive command, because it is busy processing some other MMS transaction.

  1065         

  1066         @see RSat::KMeProblem

  1067         */

  1068         KMMSTemporaryProblem					=0x27,

  1069 

  1070         // ----------------

  1071         // Permanent faults

  1072         // ----------------

  1073 

  1074         /** Command is beyond your capabilities. You understand what the

  1075         command is asking you to do, but you do not have the capability to do

  1076         it.  E.g. your code is running on a device that only supports SMS and

  1077         the command asks you to set up a call. */

  1078         KCmdBeyondMeCapabilities                =0x30,

  1079 

  1080         /** Proactive command type not understood. It is unlikely this will be

  1081         needed - it is to allow future expansion of commands. */

  1082         KCmdTypeNotUnderstood                   =0x31,

  1083 

  1084         /** Command data not understood. You understand the command type is

  1085         understood but not the accompanying data object(s). */

  1086         KCmdDataNotUnderstood                   =0x32,

  1087 

  1088         /** Command number not known. */

  1089         KCmdNumberNotKnown                      =0x33,

  1090 

  1091         /** The network returns a Supplementary Service (SS) error in response

  1092         to a previous SS command. Specific cause values are the same as given

  1093         by the network in the Return Error message.

  1094 

  1095         The network will return an error value given in the Facility

  1096         information element to indicate the problem.  Set bit 8 of

  1097         the 8-bit code to 1, then include this code in the 'additional

  1098         information' field in your response to the UICC. Set the additional

  1099         information type to RSat::KSatNetworkErrorInfo.

  1100 

  1101         If no cause code is available, set the 'additional information' field to zero.*/

  1102         KSsReturnError                          =0x34,

  1103 

  1104         /** The network returns an error in response to the phone trying to send a

  1105         short message.

  1106 

  1107         To indicate the problem, the network will return a cause value in the

  1108         RP cause element from the RP-ERROR message.  Set bit 8 of

  1109         the 8-bit code to 1, then include this code in the 'additional

  1110         information' field in your response to the UICC. Set the additional

  1111         information type to RSat::KSatNetworkErrorInfo.

  1112 

  1113         If no cause code is available, set the 'additional information' field to zero.*/

  1114         KSmsRpError  =0x35,

  1115 

  1116         /** Required values are missing.  You understand the command but one or

  1117         more required data objects are missing.  The specifications defining

  1118         the (U)SAT and CCAT toolkits define the minimum required objects for

  1119         each command. */

  1120         KErrorRequiredValuesMissing             =0x36,

  1121 

  1122         /** The network returns a USSD error in response to a previous USSD

  1123         command. Specific cause values are the same as given by the network in

  1124         a Return Error message.  This has additional information: the error value

  1125         given in the Facility information element returned by the network. Set bit 8 of

  1126         the 8-bit code to 1, then include this code in the 'additional

  1127         information' field in your response to the UICC. Set the additional

  1128         information type to RSat::KSatNetworkErrorInfo.

  1129 

  1130         If no cause code is available, set the 'additional information' field to zero.*/

  1131         KUssdReturnError                        =0x37,

  1132 

  1133         /** Multiple card commands error.

  1134 

  1135         Besides returning this value, you must return an additional value