adaptationlayer/tsy/simatktsy_dll/inc/satnotifications.h
changeset 0 63b37f68c1ce
child 8 6295dc2169f3
equal deleted inserted replaced
-1:000000000000 0:63b37f68c1ce
       
     1 /*
       
     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of the License "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description: 
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 #ifndef SATNOTIFICATIONS_H
       
    21 #define SATNOTIFICATIONS_H
       
    22 
       
    23 
       
    24 //  INCLUDES
       
    25 #include <e32base.h>    // base class cbase
       
    26 #include <etelsat.h>    // etel sat response packages
       
    27 #include <et_tsy.h>     // type declarations for tsy
       
    28 
       
    29 // CONSTANTS
       
    30 const TUint8 KRefreshMasterFileHeader             = 0x3F;
       
    31 
       
    32 
       
    33 // FORWARD DECLARATIONS
       
    34 class CSatMessHandler;
       
    35 class CTsySatMessaging;
       
    36 class TIsiReceiveC;
       
    37 class CBerTlv;
       
    38 class CTlv;
       
    39 
       
    40 // CLASS DECLARATION
       
    41 /**
       
    42 *  Sat notifications base class.
       
    43 *  Base class for SAT command notification classes.
       
    44 *
       
    45 *  @lib SIMATKTSY.LIB
       
    46 *  @since Series 60 Series60_2.6
       
    47 */
       
    48 class CSatNotificationsBase : public CBase
       
    49     {
       
    50     protected:    // Constructors
       
    51 
       
    52         /**
       
    53         * C++ default constructor.
       
    54         * @since NCP 5.0
       
    55         * @param aSatMessHandler pointer to satmessagehandler class
       
    56         * @param aSatMessaging pointer to satmessaging class
       
    57         */
       
    58         CSatNotificationsBase( CSatMessHandler* aSatMessHandler,
       
    59             CTsySatMessaging* aSatMessaging );
       
    60 
       
    61 
       
    62     public:  // Destructor
       
    63 
       
    64         /**
       
    65         * Destructor.
       
    66         * @since NCP 5.0
       
    67         */
       
    68         virtual ~CSatNotificationsBase();
       
    69 
       
    70 
       
    71     public:     // Pure virtuals
       
    72 
       
    73         /**
       
    74         * Pure virtual method for derived classes. Handles PCmd ISI messages
       
    75         * from phonet which is an interface to CellMo software.
       
    76         * @since NCP 5.0
       
    77         * @param aIsiMessage received ISI message
       
    78         * @return none
       
    79         */
       
    80         virtual void MessageReceived( const TIsiReceiveC& aIsiMessage ) = 0;
       
    81 
       
    82         /**
       
    83         * Pure virtual method for derived classes. Etel SAT Notification
       
    84         * request.
       
    85         * @since Series 60 Series60_2.6
       
    86         * @param aReqHandle notify request handle. The request handle
       
    87         * has to be non-null (.i.e pending request) in order to process
       
    88         * an incoming PCmd ISI message
       
    89         * @param aDataPtr pointer to a descriptor. Usually the pointer is
       
    90         * casted to a suitable ETel SAT data package in order to access
       
    91         * structured data fields and parameters. This is the first step
       
    92         * in the adaptation process, CellMo to Symbian.
       
    93         * @return none
       
    94         */
       
    95         virtual void Notify( const TTsyReqHandle aReqHandle,
       
    96             TDes8* aDataPtr = NULL ) = 0;
       
    97 
       
    98     public:     // New methods
       
    99 
       
   100         /**
       
   101         * Cancels notification request.
       
   102         * @since Series 60 Series60_2.6
       
   103         * @param aReqHandle notify request handle
       
   104         * @return status
       
   105         */
       
   106         TInt CancelNotification( const TTsyReqHandle aReqHandle );
       
   107 
       
   108         /**
       
   109         * Virtual method for derived classes. Handles the
       
   110         * terminal response
       
   111         * @since NCP 5.0
       
   112         * @param aRsp Pointer to a descriptor. Usually the pointer is
       
   113         * casted to a suitable ETel SAT data package in order to access
       
   114         * structured data fields and parameters. This is the first step
       
   115         * in the adaptation process, Symbian to CellMo. The terminal
       
   116         * response is reshaped into an ISI message.
       
   117         * @return status
       
   118         */
       
   119         virtual TInt TerminalResponse( TDes8* aRsp );
       
   120 
       
   121         /**
       
   122         * Return command details of the current proactive command
       
   123         * @since Series 60 Series60_2.6
       
   124         * @param none
       
   125         * @return reference to a descriptor containing the PCmd's command
       
   126         * details TLV.
       
   127         */
       
   128         TDes8& GetCmdDetails();
       
   129 
       
   130         /**
       
   131         * Return the transaction identifier of the current PCmd ISI message.
       
   132         * The transaction identifier is a CellMo specific value.
       
   133         * This value cannot be used by Etel clients.
       
   134         * @since Series 60 Series60_2.6
       
   135         * @param none
       
   136         * @return TUint8 Transaction Id value (0-255)
       
   137         */
       
   138         TUint8 GetTransactionId();
       
   139 
       
   140 
       
   141     protected: // New methods
       
   142 
       
   143         /**
       
   144         * Returns TsyReqhandle to the caller
       
   145         * @since Series 60 Series60_2.6
       
   146         * param none
       
   147         * @return TsyReqHandle
       
   148         */
       
   149         TTsyReqHandle TsyReqHandle();
       
   150 
       
   151         /**
       
   152         * Completes the notify request to Etel
       
   153         * @since Series 60 Series60_2.6
       
   154         * @param aError possible error code
       
   155         * @return none
       
   156         */
       
   157         void CompleteRequest( const TInt aError );
       
   158 
       
   159 
       
   160     protected: // Private nested class
       
   161 
       
   162         // CLASS DECLARATION
       
   163         /**
       
   164         *  Protected Sat notifications nested class.
       
   165         *  Contains the allowed general results for the specific command
       
   166         *
       
   167         *  @since NCP 5.1
       
   168         */
       
   169         class TAllowedResults
       
   170             {
       
   171             public:
       
   172 
       
   173                 /**
       
   174                 * C++ default constructor.
       
   175                 * @since NCP 5.1
       
   176                 */
       
   177                 TAllowedResults();
       
   178 
       
   179                 /**
       
   180                 * Equals-operator for TAllowedResults-class. Test wether
       
   181                 * the provided general result is allowed for the command
       
   182                 * or not.
       
   183                 * @since NCP 5.1
       
   184                 * @param aResult Result to be tested
       
   185                 * @return ETrue if allowed, EFalse if not.
       
   186                 */
       
   187                 TBool operator==( const RSat::TPCmdResult aResult ) const;
       
   188 
       
   189                 /**
       
   190                 * Nonequals-operator for TAllowedResults-class. Test wether
       
   191                 * the provided general result is not allowed for the command
       
   192                 * or not.
       
   193                 * @since NCP 5.1
       
   194                 * @param aResult Result to be tested
       
   195                 * @return ETrue if not allowed, otherwise EFalse.
       
   196                 */
       
   197                 TBool operator!=( const RSat::TPCmdResult aResult ) const;
       
   198 
       
   199                 /**
       
   200                 * Assignment operator for TAllowedResults-class. Provided
       
   201                 * general result is allowed for command.
       
   202                 * (results = RSat::KSuccess)
       
   203                 * @since NCP 5.1
       
   204                 * @param aResult Result to be allowed
       
   205                 * @return TAllowedResults-class
       
   206                 */
       
   207                 TAllowedResults& operator=( const RSat::TPCmdResult aResult );
       
   208 
       
   209                 /**
       
   210                 * Increment operator for TAllowedResults-class. Provided
       
   211                 * general result is allowed for command.
       
   212                 * (results += RSat::KPartialComprehension)
       
   213                 * @since NCP 5.1
       
   214                 * @param aResult Result to be allowed
       
   215                 * @return TAllowedResults-class
       
   216                 */
       
   217                 TAllowedResults& operator+=( const RSat::TPCmdResult aResult );
       
   218 
       
   219                 /**
       
   220                 * Increment operator for TAllowedResults-class. Results allowed
       
   221                 * by the provided results-class are appended.
       
   222                 * (results += otherResults)
       
   223                 * @since NCP 5.1
       
   224                 * @param aResults Results to be allowed
       
   225                 * @return TAllowedResults-class
       
   226                 */
       
   227                 TAllowedResults& operator+=( const TAllowedResults aResults );
       
   228 
       
   229                 /**
       
   230                 * Increment operator for TAllowedResults-class. Provided
       
   231                 * general result is allowed for command.
       
   232                 * (results = results + RSat::KSuccess)
       
   233                 * @since NCP 5.1
       
   234                 * @param aResult Result to be allowed
       
   235                 * @return TAllowedResults-class
       
   236                 */
       
   237                 TAllowedResults& operator+( const RSat::TPCmdResult aResult );
       
   238 
       
   239 
       
   240             private:    // Methods
       
   241 
       
   242                 /**
       
   243                 * Creates 64-bit field from the provided general result
       
   244                 * @since NCP 5.1
       
   245                 * @param aResult Result to be converted
       
   246                 * @return Bit field representing the general result
       
   247                 */
       
   248                 inline TUint64 CreateBitField( const RSat::TPCmdResult aResult ) const;
       
   249 
       
   250             private:    // Members
       
   251 
       
   252                 // Bit field holding the allowed results
       
   253                 TUint64     iResultField;
       
   254             };
       
   255 
       
   256 
       
   257     protected: // Data
       
   258 
       
   259         // Sat messagehandler pointer
       
   260         CSatMessHandler*    iSatMessHandler;
       
   261 
       
   262         // Sat messaging pointer
       
   263         CTsySatMessaging*   iSatMessaging;
       
   264 
       
   265         // Command details Tlv
       
   266         TBuf8<5>            iCommandDetails;
       
   267 
       
   268         // Transaction ID (0-255)
       
   269         TUint8              iTransId;
       
   270 
       
   271         // Request handle, coming from ETel
       
   272         TTsyReqHandle       iReqHandle;
       
   273 
       
   274         // Bit field for allowed general results for specific command
       
   275         TAllowedResults     iAllowedResults;
       
   276 
       
   277     private: // Friend methods
       
   278 
       
   279         /**
       
   280         * Overwrite the default plus operator for general results. Combines
       
   281         * results into TAllowedResults-class. Has to be declared as a friend
       
   282         * method to enable the usage of internal TAllowedResults-class.
       
   283         * (results = RSat::KSuccess + RSat::KPartialComprehension)
       
   284         * @since NCP 5.1
       
   285         * @param aResultA First result to be allowed
       
   286         * @param aResultB Second result to be allowed
       
   287         * @return TAllowedResults-class
       
   288         */
       
   289         friend TAllowedResults operator+( const RSat::TPCmdResult aResultA,
       
   290             const RSat::TPCmdResult aResultB );
       
   291     };
       
   292 
       
   293 
       
   294 /**
       
   295 *  SAT Display Text notification class.
       
   296 *  Instantiated by CSatMessaging class.
       
   297 *  This PCmd instructs the SAT to display a text message.
       
   298 *  It allows SIM to define the priority of that message,
       
   299 *  and the text string format.
       
   300 *
       
   301 *  @lib SIMATKTSY.lib
       
   302 *  @since Series 60 Series60_2.6
       
   303 */
       
   304 class CSatNotifyDisplayText : public CSatNotificationsBase
       
   305     {
       
   306     public:  // Constructors and destructor
       
   307 
       
   308         /**
       
   309         * C++ default constructor.
       
   310         * @since NCP 5.0
       
   311         * @param aSatMessHandler pointer to satmessagehandler class
       
   312         * @param aSatMessaging pointer to satmessaging class
       
   313         */
       
   314         CSatNotifyDisplayText( CSatMessHandler* aSatMessHandler,
       
   315             CTsySatMessaging* aSatMessaging );
       
   316 
       
   317         /**
       
   318         * Destructor.
       
   319         */
       
   320         ~CSatNotifyDisplayText();
       
   321 
       
   322 
       
   323     public: // Methods from base classes
       
   324 
       
   325         /**
       
   326         * From CSatNotificationsBase Handles DisplayText PCmd ISI message
       
   327         * @since NCP 5.0
       
   328         * @param aIsiMessage received ISI message
       
   329         * @return none
       
   330         */
       
   331         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   332 
       
   333         /**
       
   334         * From CSatNotificationsBase Notification request received from
       
   335         * ETel client
       
   336         * @since Series 60 Series60_2.6
       
   337         * @param aReqHandle request handle from ETel
       
   338         * @param aDataPtr pointer to parameter class
       
   339         * @return none
       
   340         */
       
   341         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   342 
       
   343         /**
       
   344         * From CSatNotificationsBase Handles the Display text terminal response
       
   345         * @since Series 60 Series60_2.6
       
   346         * @param aRsp pointer to a descriptor containing the response structure
       
   347         * @return status
       
   348         */
       
   349         TInt TerminalResponse( TDes8* aRsp );
       
   350 
       
   351 
       
   352     private: // Data
       
   353 
       
   354         // Package allocated by an Etel client
       
   355         RSat::TDisplayTextV2Pckg* iDisplayTextV2Pckg;
       
   356     };
       
   357 
       
   358 
       
   359 /**
       
   360 *  SAT Get Inkey notification class.
       
   361 *  Instantiated by CSatMessaging class.
       
   362 *  This PCmd instructs the SAT to display text and expect the user
       
   363 *  to enter a single character. Any response entered by the user shall
       
   364 *  be passed transparently by the SAT to the SIM.
       
   365 *
       
   366 *  @lib SIMATKTSY.lib
       
   367 *  @since Series 60 Series60_2.6
       
   368 */
       
   369 class CSatNotifyGetInkey : public CSatNotificationsBase
       
   370     {
       
   371     public:  // Constructors and destructor
       
   372 
       
   373         /**
       
   374         * C++ default constructor.
       
   375         * @since NCP 5.0
       
   376         * @param aSatMessHandler pointer to satmessagehandler class
       
   377         * @param aSatMessaging pointer to satmessaging class
       
   378         */
       
   379         CSatNotifyGetInkey( CSatMessHandler* aSatMessHandler,
       
   380             CTsySatMessaging* aSatMessaging );
       
   381 
       
   382         /**
       
   383         * Destructor.
       
   384         */
       
   385         ~CSatNotifyGetInkey();
       
   386 
       
   387 
       
   388     public: // Methods from base classes
       
   389 
       
   390         /**
       
   391         * From CSatNotificationsBase Handles GetInkey PCmd ISI message
       
   392         * @since NCP 5.0
       
   393         * @param aIsiMessage received ISI message
       
   394         * @return none
       
   395         */
       
   396         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   397 
       
   398         /**
       
   399         * From CSatNotificationsBase Notification request received from
       
   400         * ETel client
       
   401         * @since Series 60 Series60_2.6
       
   402         * @param aReqHandle request handle from ETel
       
   403         * @param aDataPtr pointer to parameter class
       
   404         * @return none
       
   405         */
       
   406         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   407 
       
   408         /**
       
   409         * From CSatNotificationsBase Handles the Get Inkey terminal response
       
   410         * @since Series 60 Series60_2.6
       
   411         * @param aRsp pointer to a descriptor containing the response structure
       
   412         * @return status
       
   413         */
       
   414         TInt TerminalResponse( TDes8* aRsp );
       
   415 
       
   416 
       
   417     private: // Data
       
   418 
       
   419         // Package allocated by an Etel client
       
   420         RSat::TGetInkeyV2Pckg* iGetInkeyV2Pckg;
       
   421     };
       
   422 
       
   423 
       
   424 /**
       
   425 *  SAT Get Input notification class.
       
   426 *  Instantiated by CSatMessaging class.
       
   427 *  This PCmd instructs the SAT to display text and that any
       
   428 *  response string entered by the user shall be passed
       
   429 *  by the SAT to the SIM. If the SIM provides a default text,
       
   430 *  the SAT shall display this default text, which user may accept,
       
   431 *  reject or edit as the response string.
       
   432 *
       
   433 *  @lib SIMATKTSY.lib
       
   434 *  @since Series 60 Series60_2.6
       
   435 */
       
   436 class CSatNotifyGetInput : public CSatNotificationsBase
       
   437     {
       
   438     public:  // Constructors and destructor
       
   439 
       
   440         /**
       
   441         * C++ default constructor.
       
   442         * @since NCP 5.0
       
   443         * @param aSatMessHandler pointer to satmessagehandler class
       
   444         * @param aSatMessaging pointer to satmessaging class
       
   445         */
       
   446         CSatNotifyGetInput( CSatMessHandler* aSatMessHandler,
       
   447             CTsySatMessaging* aSatMessaging );
       
   448 
       
   449         /**
       
   450         * Destructor.
       
   451         */
       
   452         ~CSatNotifyGetInput();
       
   453 
       
   454 
       
   455     public: // Methods from base classes
       
   456 
       
   457         /**
       
   458         * From CSatNotificationsBase Handles GetInput PCmd ISI message
       
   459         * @since NCP 5.0
       
   460         * @param aIsiMessage received ISI message
       
   461         * @return none
       
   462         */
       
   463         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   464 
       
   465         /**
       
   466         * From CSatNotificationsBase Notification request received from
       
   467         * ETel client
       
   468         * @since Series 60 Series60_2.6
       
   469         * @param aReqHandle request handle from ETel
       
   470         * @param aDataPtr pointer to parameter class
       
   471         * @return none
       
   472         */
       
   473         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   474 
       
   475         /**
       
   476         * From CSatNotificationsBase Handles the Get Input terminal response
       
   477         * @since Series 60 Series60_2.6
       
   478         * @param aRsp pointer to a descriptor containing the response structure
       
   479         * @return status
       
   480         */
       
   481         TInt TerminalResponse( TDes8* aRsp );
       
   482 
       
   483 
       
   484     private: // Data
       
   485 
       
   486         // Package received from ETel
       
   487         RSat::TGetInputV1Pckg* iGetInputV1Pckg;
       
   488     };
       
   489 
       
   490 
       
   491 /**
       
   492 *  SAT Play Tone notification class.
       
   493 *  Instantiated by CSatMessaging class.
       
   494 *  This PCmd instructs the SAT to play an audio tone.
       
   495 *
       
   496 *  @lib SIMATKTSY.lib
       
   497 *  @since Series 60 Series60_2.6
       
   498 */
       
   499 class CSatNotifyPlayTone : public CSatNotificationsBase
       
   500     {
       
   501     public:  // Constructors and destructor
       
   502 
       
   503         /**
       
   504         * C++ default constructor.
       
   505         * @since NCP 5.0
       
   506         * @param aSatMessHandler pointer to satmessagehandler class
       
   507         * @param aSatMessaging pointer to satmessaging class
       
   508         */
       
   509         CSatNotifyPlayTone( CSatMessHandler* aSatMessHandler,
       
   510             CTsySatMessaging* aSatMessaging );
       
   511 
       
   512         /**
       
   513         * Destructor.
       
   514         */
       
   515         ~CSatNotifyPlayTone();
       
   516 
       
   517 
       
   518     public: // Methods from base classes
       
   519 
       
   520         /**
       
   521         * From CSatNotificationsBase Handles PlayTone PCmd ISI message
       
   522         * @since NCP 5.0
       
   523         * @param aIsiMessage received ISI message
       
   524         * @return none
       
   525         */
       
   526         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   527 
       
   528         /**
       
   529         * From CSatNotificationsBase Notification request received from
       
   530         * ETel client
       
   531         * @since Series 60 Series60_2.6
       
   532         * @param aReqHandle request handle from ETel
       
   533         * @param aDataPtr pointer to parameter class
       
   534         * @return none
       
   535         */
       
   536         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   537 
       
   538         /**
       
   539         * From CSatNotificationsBase Handles the Play Tone terminal response
       
   540         * @since Series 60 Series60_2.6
       
   541         * @param aRsp pointer to a descriptor containing the response structure
       
   542         * @return status
       
   543         */
       
   544         TInt TerminalResponse( TDes8* aRsp );
       
   545 
       
   546 
       
   547     private: // Data
       
   548 
       
   549         // Package received from ETel
       
   550         RSat::TPlayToneV2Pckg* iPlayToneV2Pckg;
       
   551     };
       
   552 
       
   553 
       
   554 /**
       
   555 *  SAT PollInterval notification class.
       
   556 *  Instantiated by CSatMessaging class.
       
   557 *  This PCmd negotiates how often the ME shall send STATUS commands
       
   558 *  related to Proactive Polling
       
   559 *  Does not require any interaction with the Symbian OS side, and has no impact
       
   560 *  on the Etel SAT client.
       
   561 *
       
   562 *  @lib SIMATKTSY.lib
       
   563 *  @since Series 60 Series60_2.6
       
   564 */
       
   565 class CSatNotifyPollInterval : public CSatNotificationsBase
       
   566     {
       
   567     public:  // Constructors and destructor
       
   568 
       
   569         /**
       
   570         * C++ default constructor.
       
   571         * @since NCP 5.0
       
   572         * @param aSatMessHandler pointer to satmessagehandler class
       
   573         * @param aSatMessaging pointer to satmessaging class
       
   574         */
       
   575         CSatNotifyPollInterval( CSatMessHandler* aSatMessHandler,
       
   576             CTsySatMessaging* aSatMessaging );
       
   577 
       
   578         /**
       
   579         * Destructor.
       
   580         */
       
   581         ~CSatNotifyPollInterval();
       
   582 
       
   583 
       
   584     public: // Methods from base classes
       
   585 
       
   586         /**
       
   587         * From CSatNotificationsBase Handles PollInterval PCmd ISI message
       
   588         * @since NCP 5.0
       
   589         * @param aIsiMessage received ISI message
       
   590         * @return none
       
   591         */
       
   592         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   593 
       
   594         /**
       
   595         * From CSatNotificationsBase Notification request received from
       
   596         * ETel client. Not used in this PCmd since there is no interaction
       
   597         * required with Etel SAT client.
       
   598         * @since NCP 5.0
       
   599         * @param aReqHandle request handle from ETel
       
   600         * @param aDataPtr pointer to parameter class
       
   601         * @return none
       
   602         */
       
   603         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   604     };
       
   605 
       
   606 
       
   607 /**
       
   608 *  SAT SetUpMenu notification class.
       
   609 *  Instantiated by CSatMessaging class.
       
   610 *  The SIM shall supply a set of menu items, which shall be used as
       
   611 *  a main menu in SAT application. The user has then the opportunity
       
   612 *  to choose one of these menu items at his own discretion.
       
   613 *  Each item comprises a short identifier (used to indicate the selection)
       
   614 *  and a text string. Also an Alpha identifier is supplied which acts as
       
   615 *  a title for the list of menu items.
       
   616 *
       
   617 *  @lib SIMATKTSY.lib
       
   618 *  @since Series 60 Series60_2.6
       
   619 */
       
   620 class CSatNotifySetUpMenu : public CSatNotificationsBase
       
   621     {
       
   622     public:  // Constructors and destructor
       
   623 
       
   624         /**
       
   625         * C++ default constructor.
       
   626         * @since NCP 5.0
       
   627         * @param aSatMessHandler pointer to satmessagehandler class
       
   628         * @param aSatMessaging pointer to satmessaging class
       
   629         */
       
   630         CSatNotifySetUpMenu( CSatMessHandler* aSatMessHandler,
       
   631             CTsySatMessaging* aSatMessaging );
       
   632 
       
   633         /**
       
   634         * Destructor.
       
   635         */
       
   636         ~CSatNotifySetUpMenu();
       
   637 
       
   638 
       
   639     public: // Methods from base classes
       
   640 
       
   641         /**
       
   642         * From CSatNotificationsBase Handles SetUpMenu PCmd ISI message
       
   643         * @since NCP 5.0
       
   644         * @param aIsiMessage received ISI message
       
   645         * @return none
       
   646         */
       
   647         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   648 
       
   649         /**
       
   650         * From CSatNotificationsBase Notification request received from
       
   651         * ETel client.
       
   652         * @since NCP 5.0
       
   653         * @param aReqHandle request handle from ETel
       
   654         * @param aDataPtr pointer to parameter class
       
   655         * @return none
       
   656         */
       
   657         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   658 
       
   659         /**
       
   660         * From CSatNotificationsBase Handles the SetUpMenu terminal response
       
   661         * @since Series 60 Series60_2.6
       
   662         * @param aRsp pointer to a descriptor containing the response structure
       
   663         * @return status
       
   664         */
       
   665         TInt TerminalResponse( TDes8* aRsp );
       
   666 
       
   667 
       
   668     public: // New methods
       
   669 
       
   670         /**
       
   671         * From CSatNotificationsBase Handles the SetUpMenu terminal response
       
   672         * @since Series 60 Series60_2.6
       
   673         * @param none
       
   674         * @return TDes16& reference to a descriptor containing
       
   675         * a SAT application name
       
   676         */
       
   677         TDes16& SatApplicationName();
       
   678 
       
   679 
       
   680     private: // Data
       
   681 
       
   682         // Package received from ETel
       
   683         RSat::TSetUpMenuV2Pckg*     iSetUpMenuV2Pckg;
       
   684 
       
   685         // Toolkit name
       
   686         TBuf<RSat::KAlphaIdMaxSize> iToolKitName;
       
   687 
       
   688         // Buffer for isimessage. Used only if cmd is received before a notify
       
   689         HBufC8*                     iSatIsiMsg;
       
   690 
       
   691         //Flag for items next indicator
       
   692         TBool                       iItemsNextIndicatorRemoved;
       
   693     };
       
   694 
       
   695 
       
   696 /**
       
   697 *  SAT SelectItem notification class.
       
   698 *  Instantiated by CSatMessaging class.
       
   699 *  The SIM shall supply a set of items from which the user may
       
   700 *  choose one. Each item comprises a short identifier
       
   701 *  (used to indicate the selection) and a text string.
       
   702 *  Optionally the SIM may include an alpha identifier. This is intended
       
   703 *  to act as a title for the list of items.
       
   704 *
       
   705 *  @lib SIMATKTSY.lib
       
   706 *  @since Series 60 Series60_2.6
       
   707 */
       
   708 class CSatNotifySelectItem : public CSatNotificationsBase
       
   709     {
       
   710     public:  // Constructors and destructor
       
   711 
       
   712         /**
       
   713         * C++ default constructor.
       
   714         * @since NCP 5.0
       
   715         * @param aSatMessHandler pointer to satmessagehandler class
       
   716         * @param aSatMessaging pointer to satmessaging class
       
   717         */
       
   718         CSatNotifySelectItem( CSatMessHandler* aSatMessHandler,
       
   719             CTsySatMessaging* aSatMessaging );
       
   720 
       
   721         /**
       
   722         * Destructor.
       
   723         */
       
   724         ~CSatNotifySelectItem();
       
   725 
       
   726 
       
   727     public: // Methods from base classes
       
   728 
       
   729         /**
       
   730         * Initializer
       
   731         * @param aSatMessHandler pointer to satmessagehandler class
       
   732         * @param aSatMessaging pointer to satmessaging class
       
   733         */
       
   734         void ConstructL( CSatMessHandler* aSatMessHandler,
       
   735             CTsySatMessaging* aSatMessaging );
       
   736 
       
   737         /**
       
   738         * From CSatNotificationsBase Handles SelectItem PCmd ISI message
       
   739         * @since NCP 5.0
       
   740         * @param aIsiMessage received ISI message
       
   741         * @return none
       
   742         */
       
   743         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   744 
       
   745         /**
       
   746         * From CSatNotificationsBase Notification request received from
       
   747         * ETel client
       
   748         * @since Series 60 Series60_2.6
       
   749         * @param aReqHandle request handle from ETel
       
   750         * @param aDataPtr pointer to parameter class
       
   751         * @return none
       
   752         */
       
   753         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   754 
       
   755         /**
       
   756         * From CSatNotificationsBase Handles the SelectItem terminal response
       
   757         * @since Series 60 Series60_2.6
       
   758         * @param aRsp pointer to a descriptor containing the response structure
       
   759         * @return status
       
   760         */
       
   761         TInt TerminalResponse( TDes8* aRsp );
       
   762 
       
   763 
       
   764     private: // Data
       
   765 
       
   766         // Package allocated by an Etel client
       
   767         RSat::TSelectItemV2Pckg*    iSelectItemV2Pckg;
       
   768 
       
   769         //Flag for items next indicator
       
   770         TBool                       iItemNextIndicatorRemoved;
       
   771     };
       
   772 
       
   773 
       
   774 /**
       
   775 *  SAT SendSm notification class.
       
   776 *  Instantiated by CSatMessaging class.
       
   777 *  This PCmd instructs the SAT to send a short message to the
       
   778 *  network.
       
   779 *
       
   780 *  @lib SIMATKTSY.lib
       
   781 *  @since Series 60 Series60_2.6
       
   782 */
       
   783 class CSatNotifySendSm : public CSatNotificationsBase
       
   784     {
       
   785     public:  // Constructors and destructor
       
   786 
       
   787         /**
       
   788         * C++ default constructor.
       
   789         * @since NCP 5.0
       
   790         * @param aSatMessHandler pointer to satmessagehandler class
       
   791         * @param aSatMessaging pointer to satmessaging class
       
   792         */
       
   793         CSatNotifySendSm( CSatMessHandler* aSatMessHandler,
       
   794             CTsySatMessaging* aSatMessaging );
       
   795 
       
   796         /**
       
   797         * Destructor.
       
   798         */
       
   799         ~CSatNotifySendSm();
       
   800 
       
   801 
       
   802     public: // Methods from base classes
       
   803 
       
   804         /**
       
   805         * From CSatNotificationsBase Handles SendSm PCmd ISI message
       
   806         * @since NCP 5.0
       
   807         * @param aIsiMessage received ISI message
       
   808         * @return none
       
   809         */
       
   810         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   811 
       
   812         /**
       
   813         * From CSatNotificationsBase Notification request received from
       
   814         * ETel client
       
   815         * @since Series 60 Series60_2.6
       
   816         * @param aReqHandle request handle from ETel
       
   817         * @param aDataPtr pointer to parameter class
       
   818         * @return none
       
   819         */
       
   820         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   821 
       
   822         /**
       
   823         * From CSatNotificationsBase Handles the SendSm terminal response
       
   824         * @since Series 60 Series60_2.6
       
   825         * @param aRsp pointer to a descriptor containing the response structure
       
   826         * @return status
       
   827         */
       
   828         TInt TerminalResponse( TDes8* aRsp );
       
   829 
       
   830 
       
   831     public: // New methods
       
   832 
       
   833         /**
       
   834         * From CSatNotificationsBase Get index of TP-UDL(User Data Length)
       
   835         * field from Tpdu
       
   836         * @param aTpdu pointer to Tpdu data
       
   837         * @return TUint8 index of TP-UDL field
       
   838         */
       
   839         TUint8 GetTpUdlIndex( TPtrC8 aTpdu );
       
   840 
       
   841         /**
       
   842         * From CSatNotificationsBase Get index of TP-DCS(Data Coding Scheme)
       
   843         * field from Tpdu
       
   844         * @param aTpdu pointer to Tpdu data
       
   845         * @return TUint8 index of TP-DCS field
       
   846         */
       
   847         TUint8 GetTpDcsIndex( TPtrC8 aTpdu );
       
   848 
       
   849         /**
       
   850         * From CSatNotificationsBase Check TPDU validity
       
   851         * @since Series 60 Series60_2.6
       
   852         * @param aTpdu pointer to Tpdu data
       
   853         * @return TInt KErrNone or KErrCorrupt
       
   854         */
       
   855         TInt CheckTpdu( TPtrC8 aTpdu );
       
   856 
       
   857         /**
       
   858         * From CSatNotificationsBase Pack SMS if it is required by the sim
       
   859         * @since Series 60 Series60_2.6
       
   860         * @param aTpdu pointer to received Tpdu data
       
   861         * @param aSendSm reference to package containing packed sms data
       
   862         * @return TInt KErrNone or KErrCorrupt
       
   863         */
       
   864         TInt PackSms( TPtrC8 aTpdu, TTpdu& aSendSm );
       
   865 
       
   866 
       
   867     private: // Data
       
   868 
       
   869         // Package allocated by an Etel client
       
   870         RSat::TSendSmV1Pckg* iSendSmV1Pckg;
       
   871 
       
   872     };
       
   873 
       
   874 
       
   875 /**
       
   876 *  SAT SendDtmf notification class.
       
   877 *  Instantiated by CSatMessaging class.
       
   878 *  This PCmd instructs the SAT to send a DTMF string towards the network.
       
   879 *
       
   880 *  @lib SIMATKTSY.lib
       
   881 *  @since Series 60 Series60_2.6
       
   882 */
       
   883 class CSatNotifySendDtmf : public CSatNotificationsBase
       
   884     {
       
   885     public:  // Constructors and destructor
       
   886 
       
   887         /**
       
   888         * C++ default constructor.
       
   889         * @since NCP 5.0
       
   890         * @param aSatMessHandler pointer to satmessagehandler class
       
   891         * @param aSatMessaging pointer to satmessaging class
       
   892         */
       
   893         CSatNotifySendDtmf( CSatMessHandler* aSatMessHandler,
       
   894             CTsySatMessaging* aSatMessaging );
       
   895 
       
   896         /**
       
   897         * Destructor.
       
   898         */
       
   899         ~CSatNotifySendDtmf();
       
   900 
       
   901 
       
   902     public: // Methods from base classes
       
   903 
       
   904         /**
       
   905         * From CSatNotificationsBase Handles SendDtmf PCmd ISI message
       
   906         * @since NCP 5.0
       
   907         * @param aIsiMessage received ISI message
       
   908         * @return none
       
   909         */
       
   910         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   911 
       
   912         /**
       
   913         * From CSatNotificationsBase Notification request received from
       
   914         * ETel client
       
   915         * @since Series 60 Series60_2.6
       
   916         * @param aReqHandle request handle from ETel
       
   917         * @param aDataPtr pointer to parameter class
       
   918         * @return none
       
   919         */
       
   920         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   921 
       
   922         /**
       
   923         * From CSatNotificationsBase Handles the SendDtmf terminal response
       
   924         * @since Series 60 Series60_2.6
       
   925         * @param aRsp pointer to a descriptor containing the response structure
       
   926         * @return status
       
   927         */
       
   928         TInt TerminalResponse( TDes8* aRsp );
       
   929 
       
   930 
       
   931     private: // Data
       
   932 
       
   933         // Package allocated by an Etel client
       
   934         RSat::TSendDtmfV1Pckg* iSendDtmfV1Pckg;
       
   935     };
       
   936 
       
   937 
       
   938 /**
       
   939 *  SAT SendSs notification class.
       
   940 *  Instantiated by CSatMessaging class.
       
   941 *  This PCmd instructs the SAT to send a SS string towards the network.
       
   942 *
       
   943 *  @lib SIMATKTSY.lib
       
   944 *  @since Series 60 Series60_2.6
       
   945 */
       
   946 class CSatNotifySendSs : public CSatNotificationsBase
       
   947     {
       
   948     public:  // Constructors and destructor
       
   949 
       
   950         /**
       
   951         * C++ default constructor.
       
   952         * @since NCP 5.0
       
   953         * @param aSatMessHandler pointer to satmessagehandler class
       
   954         * @param aSatMessaging pointer to satmessaging class
       
   955         */
       
   956         CSatNotifySendSs( CSatMessHandler* aSatMessHandler,
       
   957             CTsySatMessaging* aSatMessaging );
       
   958 
       
   959         /**
       
   960         * Destructor.
       
   961         */
       
   962         ~CSatNotifySendSs();
       
   963 
       
   964 
       
   965     public: // Methods from base classes
       
   966 
       
   967         /**
       
   968         * From CSatNotificationsBase Handles SendSs PCmd ISI message
       
   969         * @since NCP 5.0
       
   970         * @param aIsiMessage received ISI message
       
   971         * @return none
       
   972         */
       
   973         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
   974 
       
   975         /**
       
   976         * From CSatNotificationsBase Notification request received from
       
   977         * ETel client
       
   978         * @since Series 60 Series60_2.6
       
   979         * @param aReqHandle request handle from ETel
       
   980         * @param aDataPtr pointer to parameter class
       
   981         * @return none
       
   982         */
       
   983         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
   984 
       
   985         /**
       
   986         * From CSatNotificationsBase Handles the SendSs terminal response
       
   987         * @since Series 60 Series60_2.6
       
   988         * @param aRsp pointer to a descriptor containing the response structure
       
   989         * @return status
       
   990         */
       
   991         TInt TerminalResponse( TDes8* aRsp );
       
   992 
       
   993 
       
   994     public: // New methods
       
   995 
       
   996         /**
       
   997         * From CSatNotificationsBase Checks SS string if it is call forwarding
       
   998         * and append '+' character.
       
   999         * @since Series 60 Series60_2.6
       
  1000         * @param aSource Original string is received from SIM
       
  1001         * @param aSsString SS string compatible with ETel SAT
       
  1002         * @return none
       
  1003         */
       
  1004         void CheckCallForwarding( TPtrC8 aSource, RSat::TSsString& aSsString );
       
  1005 
       
  1006         /**
       
  1007         * From CSatNotificationsBase Checks validity of SS string.
       
  1008         * If string includes undefined SS
       
  1009         * characters or length is zero then return KErrCorrupt
       
  1010         * @since Series 60 Series60_2.6
       
  1011         * @param aSsString Original string is received from SIM
       
  1012         * @return TInt KErrNone or KErrCorrupt
       
  1013         */
       
  1014         TInt CheckSsStringValidity( TPtrC8 aSsString );
       
  1015 
       
  1016 
       
  1017     private: // Data
       
  1018 
       
  1019         // Package allocated by an Etel client
       
  1020         RSat::TSendSsV1Pckg*    iSendSsV1Pckg;
       
  1021     };
       
  1022 
       
  1023 
       
  1024 /**
       
  1025 *  SAT SendUssd notification class.
       
  1026 *  Instantiated by CSatMessaging class.
       
  1027 *  This PCmd instructs the SAT to send a USSD string towards the network.
       
  1028 *
       
  1029 *  @lib SIMATKTSY.lib
       
  1030 *  @since Series 60 Series60_2.6
       
  1031 */
       
  1032 class CSatNotifySendUssd : public CSatNotificationsBase
       
  1033     {
       
  1034     public:  // Constructors and destructor
       
  1035 
       
  1036         /**
       
  1037         * C++ default constructor.
       
  1038         * @since NCP 5.0
       
  1039         * @param aSatMessHandler pointer to satmessagehandler class
       
  1040         * @param aSatMessaging pointer to satmessaging class
       
  1041         */
       
  1042         CSatNotifySendUssd( CSatMessHandler* aSatMessHandler,
       
  1043             CTsySatMessaging* aSatMessaging );
       
  1044 
       
  1045         /**
       
  1046         * Destructor.
       
  1047         */
       
  1048         ~CSatNotifySendUssd();
       
  1049 
       
  1050 
       
  1051     public: // Methods from base classes
       
  1052 
       
  1053         /**
       
  1054         * From CSatNotificationsBase Handles SendUssd PCmd ISI message
       
  1055         * @since NCP 5.0
       
  1056         * @param aIsiMessage received ISI message
       
  1057         * @return none
       
  1058         */
       
  1059         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1060 
       
  1061         /**
       
  1062         * From CSatNotificationsBase Notification request received from
       
  1063         * ETel client
       
  1064         * @since Series 60 Series60_2.6
       
  1065         * @param aReqHandle request handle from ETel
       
  1066         * @param aDataPtr pointer to parameter class
       
  1067         * @return none
       
  1068         */
       
  1069         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1070 
       
  1071         /**
       
  1072         * From CSatNotificationsBase Handles the SendUssd terminal response
       
  1073         * @since Series 60 Series60_2.6
       
  1074         * @param aRsp pointer to a descriptor containing the response structure
       
  1075         * @return status
       
  1076         */
       
  1077         TInt TerminalResponse( TDes8* aRsp );
       
  1078 
       
  1079 
       
  1080     private: // Data
       
  1081 
       
  1082         // Package allocated by an Etel client
       
  1083         RSat::TSendUssdV1Pckg*  iSendUssdV1Pckg;
       
  1084     };
       
  1085 
       
  1086 
       
  1087 /**
       
  1088 *  SAT SetUpCall notification class.
       
  1089 *  Instantiated by CSatMessaging class.
       
  1090 *  This PCmd instructs the SAT to setup a call.
       
  1091 *  Can be setup in three different ways:
       
  1092 *  - Set up a call, only if not currently busy on another call
       
  1093 *  - Set up a call, put all other call on hold
       
  1094 *  - Set up a call, disconnect other calls
       
  1095 *
       
  1096 *  @lib SIMATKTSY.lib
       
  1097 *  @since Series 60 Series60_2.6
       
  1098 */
       
  1099 class CSatNotifySetUpCall : public CSatNotificationsBase
       
  1100     {
       
  1101     public:  // Constructors and destructor
       
  1102 
       
  1103         /**
       
  1104         * C++ default constructor.
       
  1105         * @since NCP 5.0
       
  1106         * @param aSatMessHandler pointer to satmessagehandler class
       
  1107         * @param aSatMessaging pointer to satmessaging class
       
  1108         */
       
  1109         CSatNotifySetUpCall( CSatMessHandler* aSatMessHandler,
       
  1110             CTsySatMessaging* aSatMessaging );
       
  1111 
       
  1112         /**
       
  1113         * Destructor.
       
  1114         */
       
  1115         ~CSatNotifySetUpCall();
       
  1116 
       
  1117 
       
  1118     public: // Methods from base classes
       
  1119 
       
  1120         /**
       
  1121         * From CSatNotificationsBase Handles SetUpCall PCmd ISI message
       
  1122         * @since NCP 5.0
       
  1123         * @param aIsiMessage received ISI message
       
  1124         * @return none
       
  1125         */
       
  1126         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1127 
       
  1128         /**
       
  1129         * From CSatNotificationsBase Notification request received from
       
  1130         * ETel client
       
  1131         * @since Series 60 Series60_2.6
       
  1132         * @param aReqHandle request handle from ETel
       
  1133         * @param aDataPtr pointer to parameter class
       
  1134         * @return none
       
  1135         */
       
  1136         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1137 
       
  1138         /**
       
  1139         * From CSatNotificationsBase Handles the SetUpCall terminal response
       
  1140         * @since Series 60 Series60_2.6
       
  1141         * @param aRsp pointer to a descriptor containing the response structure
       
  1142         * @return status
       
  1143         */
       
  1144         TInt TerminalResponse( TDes8* aRsp );
       
  1145 
       
  1146 
       
  1147     public: // New methods
       
  1148 
       
  1149         /**
       
  1150         * From CSatNotificationsBase Cache call connected event
       
  1151         * @since Series 60 Series60_2.6
       
  1152         * @param aEnvelope reference to a descriptor containing envelope data.
       
  1153         * @return none
       
  1154         */
       
  1155         void StoreCallConnectedEvent( const TDesC8& aEnvelope );
       
  1156 
       
  1157 
       
  1158     private: // Data
       
  1159 
       
  1160         // Package allocated by an Etel client
       
  1161         RSat::TSetUpCallV1Pckg* iSetUpCallV1Pckg;
       
  1162 
       
  1163         // Cache for Call connected event
       
  1164         TBuf8<12>               iCallConnectedEvent;
       
  1165 
       
  1166     };
       
  1167 
       
  1168 
       
  1169 /**
       
  1170 *  SAT Refresh notification class.
       
  1171 *  Instantiated by CSatMessaging class.
       
  1172 *  The purpose of this PCmd is to allow the SAT
       
  1173 *  (which alerts other applications in the phone) to be notified
       
  1174 *  of the changes in SIM configuration that have occurred as
       
  1175 *  the result of a SIM application activity. It is up to SAT to
       
  1176 *  ensure this is done correctly..
       
  1177 *
       
  1178 *  @lib SIMATKTSY.lib
       
  1179 *  @since Series 60 Series60_2.6
       
  1180 */
       
  1181 class CSatNotifyRefresh : public CSatNotificationsBase
       
  1182     {
       
  1183     public: // Data types
       
  1184 
       
  1185         // Enumaration of cache EF files.
       
  1186         enum TCachedSimAtkFiles
       
  1187             {
       
  1188             KCacheEFSST     = 0x01, // SIM Service table
       
  1189             KCacheEFCBMID   = 0x02, // CB DataDownload message IDs
       
  1190             // Next 0x04, 0x08 etc..
       
  1191             };
       
  1192 
       
  1193     public: // Constructors and destructor
       
  1194 
       
  1195         /**
       
  1196         * C++ default constructor.
       
  1197         * @since NCP 5.0
       
  1198         * @param aSatMessHandler pointer to satmessagehandler class
       
  1199         * @param aSatMessaging pointer to satmessaging class
       
  1200         */
       
  1201         CSatNotifyRefresh( CSatMessHandler* aSatMessHandler,
       
  1202             CTsySatMessaging* aSatMessaging );
       
  1203 
       
  1204         /**
       
  1205         * Destructor.
       
  1206         */
       
  1207         ~CSatNotifyRefresh();
       
  1208 
       
  1209 
       
  1210     public: // Methods from base classes
       
  1211 
       
  1212         /**
       
  1213         * From CSatNotificationsBase Handles Refresh PCmd ISI message
       
  1214         * @since NCP 5.0
       
  1215         * @param aIsiMessage received ISI message
       
  1216         * @return none
       
  1217         */
       
  1218         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1219 
       
  1220         /**
       
  1221         * From CSatNotificationsBase Notification request received from
       
  1222         * ETel client
       
  1223         * @since Series 60 Series60_2.6
       
  1224         * @param aReqHandle request handle from ETel
       
  1225         * @param aDataPtr pointer to parameter class
       
  1226         * @return none
       
  1227         */
       
  1228         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1229 
       
  1230         /**
       
  1231         * From CSatNotificationsBase Handles the Refresh terminal response
       
  1232         * @since Series 60 Series60_2.6
       
  1233         * @param aRsp pointer to a descriptor containing the response structure
       
  1234         * @return status
       
  1235         */
       
  1236         TInt TerminalResponse( TDes8* aRsp );
       
  1237 
       
  1238 
       
  1239     public: // New methods
       
  1240 
       
  1241         /**
       
  1242         * From CSatNotificationsBase Notification request for RefreshRequired
       
  1243         * received from Etel client
       
  1244         * @since Series 60 Series60_2.6
       
  1245         * @param aReqHandle request handle from ETel
       
  1246         * @param aDataPtr pointer to parameter class
       
  1247         * @return none
       
  1248         */
       
  1249         void NotifyRefreshRequired( const TTsyReqHandle aRegHandle,
       
  1250             TDes8* aDataPtr = NULL );
       
  1251 
       
  1252         /**
       
  1253         * From CSatNotificationsBase Cancels notification of
       
  1254         * RefreshRequiredParams request.
       
  1255         * @since Series 60 Series60_2.6
       
  1256         * @param aReqHandle notify request handle
       
  1257         * @return status
       
  1258         */
       
  1259         TInt CancelRefreshRequiredNotification(
       
  1260             const TTsyReqHandle aReqHandle );
       
  1261 
       
  1262         /**
       
  1263         * From CSatNotificationsBase Response for RefreshRequired notification
       
  1264         * @since Series 60 Series60_2.6
       
  1265         * @param aDataPtr Pointer to descriptor containing response data
       
  1266         * @return TInt
       
  1267         */
       
  1268         TInt RefreshAllowed( TDesC8* aDataPtr );
       
  1269 
       
  1270         /**
       
  1271         * From CSatNotificationsBase Overloads original protected
       
  1272         * CompleteRequest method from Base class.
       
  1273         * @since Series 60 Series60_2.6
       
  1274         * @param aError possible error code
       
  1275         * @return none
       
  1276         */
       
  1277         void CompleteRequest( const TInt aError );
       
  1278 
       
  1279         /**
       
  1280         * From CSatNotificationsBase Returns list of files that are
       
  1281         * cached in SIM ATK TSY
       
  1282         * @since Series 60 Series60_2.6
       
  1283         * @param none
       
  1284         * @return TUin16 iInternalCache
       
  1285         */
       
  1286         TUint16 CachedFiles() const;
       
  1287 
       
  1288 
       
  1289     private: // New methods
       
  1290 
       
  1291         /**
       
  1292         * Maps a 3GPP refresh value to UICC refresh value
       
  1293         * @param a3GppRefresh Command Qualifier from 3GPP spec
       
  1294         * @return TUint8 ServiceType from UICC specification
       
  1295         */
       
  1296         TUint8 Map3GppRefreshToUiccValues( const TUint8 a3GppRefresh );
       
  1297 
       
  1298 
       
  1299     private: // Data
       
  1300 
       
  1301         // Package allocated by an Etel client
       
  1302         RSat::TRefreshV2Pckg*                  iRefreshV2Pckg;
       
  1303 
       
  1304         // Package allocated by an Etel client
       
  1305         RSat::TRefreshV2Pckg*                  iRefreshRequiredV2Pckg;
       
  1306 
       
  1307         // file list with full path
       
  1308         TBuf8<RSat::KRefreshedFileListMaxSize> iFileList;
       
  1309 
       
  1310         // To store Aplication id
       
  1311         TBuf8<RSat::KAidMaxSize>               iAid;
       
  1312 
       
  1313         // Request handle for Refresh Required, coming from ETel
       
  1314         TTsyReqHandle                          iReqHandleRefreshRequired;
       
  1315 
       
  1316         // List of files that are cached in SIM ATK TSY
       
  1317         TUint16                                iInternalCache;
       
  1318     };
       
  1319 
       
  1320 
       
  1321 /**
       
  1322 *  SAT SimSessionEnd notification class.
       
  1323 *  Instantiated by CSatMessaging class.
       
  1324 *  SIM Session end tells the client when the last PCmd in SIM application has
       
  1325 *  been processed, i.e. the SIM application has ended.
       
  1326 *
       
  1327 *  @lib SIMATKTSY.lib
       
  1328 *  @since Series 60 Series60_2.6
       
  1329 */
       
  1330 class CSatNotifySimSessionEnd : public CSatNotificationsBase
       
  1331     {
       
  1332     public:  // Constructors and destructor
       
  1333 
       
  1334         /**
       
  1335         * C++ default constructor.
       
  1336         * @since NCP 5.0
       
  1337         * @param aSatMessHandler pointer to satmessagehandler class
       
  1338         * @param aSatMessaging pointer to satmessaging class
       
  1339         */
       
  1340         CSatNotifySimSessionEnd( CSatMessHandler* aSatMessHandler,
       
  1341             CTsySatMessaging* aSatMessaging );
       
  1342 
       
  1343         /**
       
  1344         * Destructor.
       
  1345         */
       
  1346         ~CSatNotifySimSessionEnd();
       
  1347 
       
  1348 
       
  1349     public: // Methods from base classes
       
  1350 
       
  1351         /**
       
  1352         * From CSatNotificationsBase Handles SimSessionEnd PCmd ISI message
       
  1353         * @since NCP 5.0
       
  1354         * @param aIsiMessage received ISI message
       
  1355         * @return none
       
  1356         */
       
  1357         void MessageReceived( const TIsiReceiveC& /*aIsiMessage*/ );
       
  1358 
       
  1359         /**
       
  1360         * From CSatNotificationsBase Notification request received from
       
  1361         * ETel client
       
  1362         * @since Series 60 Series60_2.6
       
  1363         * @param aReqHandle request handle from ETel
       
  1364         * @param aDataPtr pointer to parameter class
       
  1365         * @return none
       
  1366         */
       
  1367         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1368     };
       
  1369 
       
  1370 
       
  1371 /**
       
  1372 *  SAT SetUpIdleModeText notification class.
       
  1373 *  Instantiated by CSatMessaging class.
       
  1374 *  This PCmd instructs the SAT to change the text displayed
       
  1375 *  by the mobile equipment whenever it is in idle mode.
       
  1376 *
       
  1377 *  @lib SIMATKTSY.lib
       
  1378 *  @since Series 60 Series60_2.6
       
  1379 */
       
  1380 class CSatNotifySetUpIdleModeText : public CSatNotificationsBase
       
  1381     {
       
  1382     public:  // Constructors and destructor
       
  1383 
       
  1384         /**
       
  1385         * C++ default constructor.
       
  1386         * @since NCP 5.0
       
  1387         * @param aSatMessHandler pointer to satmessagehandler class
       
  1388         * @param aSatMessaging pointer to satmessaging class
       
  1389         */
       
  1390         CSatNotifySetUpIdleModeText( CSatMessHandler* aSatMessHandler,
       
  1391             CTsySatMessaging* aSatMessaging );
       
  1392 
       
  1393         /**
       
  1394         * Destructor.
       
  1395         */
       
  1396         ~CSatNotifySetUpIdleModeText();
       
  1397 
       
  1398 
       
  1399     public: // Methods from base classes
       
  1400 
       
  1401         /**
       
  1402         * From CSatNotificationsBase Handles SetUpIdleModeText PCmd ISI message
       
  1403         * @since NCP 5.0
       
  1404         * @param aIsiMessage received ISI message
       
  1405         * @return none
       
  1406         */
       
  1407         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1408 
       
  1409         /**
       
  1410         * From CSatNotificationsBase Notification request received from
       
  1411         * ETel client
       
  1412         * @since Series 60 Series60_2.6
       
  1413         * @param aReqHandle request handle from ETel
       
  1414         * @param aDataPtr pointer to parameter class
       
  1415         * @return none
       
  1416         */
       
  1417         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1418 
       
  1419         /**
       
  1420         * From CSatNotificationsBase Handles the SetUpIdleModeText
       
  1421         * terminal response
       
  1422         * @since Series 60 Series60_2.6
       
  1423         * @param aRsp pointer to a descriptor containing the response structure
       
  1424         * @return status
       
  1425         */
       
  1426         TInt TerminalResponse( TDes8* aRsp );
       
  1427 
       
  1428 
       
  1429     private: // Data
       
  1430 
       
  1431         // Package allocated by an Etel client
       
  1432         RSat::TSetUpIdleModeTextV1Pckg* iSetUpIdleModeTextV1Pckg;
       
  1433 
       
  1434     };
       
  1435 
       
  1436 
       
  1437 /**
       
  1438 *  SAT CallControlRequest notification class.
       
  1439 *  Instantiated by CSatMessaging class.
       
  1440 *  CallControlRequest is not treated as a proactive command in Series60.
       
  1441 *  The method CompleteNotification is used to notify an Etel SAT client
       
  1442 *  that the SIM Applet has provided an alpha identifier in response to
       
  1443 *  a CallControl envelope. The class CSatCC implements the CallControl
       
  1444 *  functionality.
       
  1445 *
       
  1446 *  @lib SIMATKTSY.lib
       
  1447 *  @since Series 60 Series60_2.6
       
  1448 */
       
  1449 class CSatNotifyCallControlRequest : public CSatNotificationsBase
       
  1450     {
       
  1451     public:  // Constructors and destructor
       
  1452 
       
  1453         /**
       
  1454         * C++ default constructor.
       
  1455         * @since NCP 5.0
       
  1456         * @param aSatMessHandler pointer to satmessagehandler class
       
  1457         * @param aSatMessaging pointer to satmessaging class
       
  1458         */
       
  1459         CSatNotifyCallControlRequest( CSatMessHandler* aSatMessHandler,
       
  1460             CTsySatMessaging* aSatMessaging );
       
  1461 
       
  1462         /**
       
  1463         * Destructor.
       
  1464         */
       
  1465         ~CSatNotifyCallControlRequest();
       
  1466 
       
  1467 
       
  1468     public: // Methods from base classes
       
  1469 
       
  1470         /**
       
  1471         * From CSatNotificationsBase Handles CallControlRequest PCmd ISI message
       
  1472         * Not in use.
       
  1473         * @since NCP 5.0
       
  1474         * @param aIsiMessage received ISI message
       
  1475         * @return none
       
  1476         */
       
  1477         void MessageReceived( const TIsiReceiveC& /*aIsiMessage*/ );
       
  1478 
       
  1479         /**
       
  1480         * From CSatNotificationsBase Notification request received from
       
  1481         * ETel client
       
  1482         * @since Series 60 Series60_2.6
       
  1483         * @param aReqHandle request handle from ETel
       
  1484         * @param aDataPtr pointer to parameter class
       
  1485         * @return none
       
  1486         */
       
  1487         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1488 
       
  1489 
       
  1490     public: // New methods
       
  1491 
       
  1492         /**
       
  1493         * From CSatNotificationsBase Notification completion
       
  1494         * @since Series 60 Series60_2.6
       
  1495         * @param aAlphaId alpha identifier in Etel SAT format
       
  1496         * @param aResult call control result in Etel SAT format
       
  1497         * @return none
       
  1498         */
       
  1499         void CompleteNotification( TDesC& aAlphaId,
       
  1500             RSat::TControlResult aResult );
       
  1501 
       
  1502         /**
       
  1503         * From CSatNotificationsBase Notification completion for CC GPRS
       
  1504         * @param aAlphaId: Alpha identifier in Etel SAT format
       
  1505         * @param aPdpContextParameters: PDP Context Parameters
       
  1506         * @param aResult: Call control result in Etel SAT format
       
  1507         * @return none
       
  1508         */
       
  1509         void CompleteNotification(
       
  1510             const TDesC& aAlphaId,
       
  1511             const RSat::TControlResult aResult );
       
  1512 
       
  1513         /**
       
  1514         * From CSatNotificationsBase Notification completion
       
  1515         * @param aCcResult CC result mapped to ISA values
       
  1516         * @param aEnvelopeResponse response data received from SIM application
       
  1517         * @return none
       
  1518         */
       
  1519         void CompleteNotificationL( const TUint8 aCcResult,
       
  1520             TPtrC8 aEnvelopeResponse );
       
  1521 
       
  1522     private: // Data
       
  1523 
       
  1524         // Package allocated by an Etel client
       
  1525         RSat::TCallControlV5Pckg*   iCallControlPckg;
       
  1526     };
       
  1527 
       
  1528 
       
  1529 /**
       
  1530 *  SAT LaunchBrowser notification class.
       
  1531 *  Instantiated by CSatMessaging class.
       
  1532 *  This PCmd instructs the SAT to start a web browser application instance on
       
  1533 *  the mobile equipment.
       
  1534 *
       
  1535 *  @lib SIMATKTSY.lib
       
  1536 *  @since Series 60 Series60_2.6
       
  1537 */
       
  1538 class CSatNotifyLaunchBrowser : public CSatNotificationsBase
       
  1539     {
       
  1540     public:  // Constructors and destructor
       
  1541 
       
  1542         /**
       
  1543         * C++ default constructor.
       
  1544         * @since NCP 5.0
       
  1545         * @param aSatMessHandler pointer to satmessagehandler class
       
  1546         * @param aSatMessaging pointer to satmessaging class
       
  1547         */
       
  1548         CSatNotifyLaunchBrowser( CSatMessHandler* aSatMessHandler,
       
  1549             CTsySatMessaging* aSatMessaging );
       
  1550 
       
  1551         /**
       
  1552         * Destructor.
       
  1553         */
       
  1554         ~CSatNotifyLaunchBrowser();
       
  1555 
       
  1556 
       
  1557     public: // Methods from base classes
       
  1558 
       
  1559         /**
       
  1560         * From CSatNotificationsBase Handles LaunchBrowser PCmd ISI message
       
  1561         * @since NCP 5.0
       
  1562         * @param aIsiMessage received ISI message
       
  1563         * @return none
       
  1564         */
       
  1565         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1566 
       
  1567         /**
       
  1568         * From CSatNotificationsBase Notification request received from
       
  1569         * ETel client
       
  1570         * @since Series 60 Series60_2.6
       
  1571         * @param aReqHandle request handle from ETel
       
  1572         * @param aDataPtr pointer to parameter class
       
  1573         * @return none
       
  1574         */
       
  1575         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1576 
       
  1577         /**
       
  1578         * From CSatNotificationsBase Handles the LaunchBrowser terminal
       
  1579         * response
       
  1580         * @since Series 60 Series60_2.6
       
  1581         * @param aRsp pointer to a descriptor containing the response structure
       
  1582         * @return status
       
  1583         */
       
  1584         TInt TerminalResponse( TDes8* aRsp );
       
  1585 
       
  1586 
       
  1587     private: // Data
       
  1588 
       
  1589         // Package allocated by an Etel client
       
  1590         RSat::TLaunchBrowserV2Pckg* iLaunchBrowserV2Pckg;
       
  1591     };
       
  1592 
       
  1593 
       
  1594 /**
       
  1595 *  SAT SetUpEventList notification class.
       
  1596 *  Instantiated by CSatMessaging class.
       
  1597 *  This PCmd instructs the SAT to set up an event list in order
       
  1598 *  to be able to process events received from ETel SAT clients
       
  1599 *  or CellMo clients.
       
  1600 *
       
  1601 *  @lib SIMATKTSY.lib
       
  1602 *  @since Series 60 Series60_2.6
       
  1603 */
       
  1604 class CSatNotifySetUpEventList : public CSatNotificationsBase
       
  1605     {
       
  1606     public:  // Constructors and destructor
       
  1607 
       
  1608         /**
       
  1609         * C++ default constructor.
       
  1610         * @since NCP 5.0
       
  1611         * @param aSatMessHandler pointer to satmessagehandler class
       
  1612         * @param aSatMessaging pointer to satmessaging class
       
  1613         */
       
  1614         CSatNotifySetUpEventList( CSatMessHandler* aSatMessHandler,
       
  1615             CTsySatMessaging* aSatMessaging );
       
  1616 
       
  1617         /**
       
  1618         * Destructor.
       
  1619         */
       
  1620         ~CSatNotifySetUpEventList();
       
  1621 
       
  1622 
       
  1623     public: // Methods from base classes
       
  1624 
       
  1625         /**
       
  1626         * From CSatNotificationsBase Handles SetUpEventList PCmd ISI message
       
  1627         * @since NCP 5.0
       
  1628         * @param aIsiMessage received ISI message
       
  1629         * @return none
       
  1630         */
       
  1631         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1632 
       
  1633         /**
       
  1634         * From CSatNotificationsBase Notification request received from
       
  1635         * ETel client
       
  1636         * @since Series 60 Series60_2.6
       
  1637         * @param aReqHandle request handle from ETel
       
  1638         * @param aDataPtr pointer to parameter class
       
  1639         * @return none
       
  1640         */
       
  1641         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1642 
       
  1643         /**
       
  1644         * From CSatNotificationsBase Handles the SetUpEventList terminal
       
  1645         * response
       
  1646         * @since Series 60 Series60_2.6
       
  1647         * @param aRsp pointer to a descriptor containing the response structure
       
  1648         * @return status
       
  1649         */
       
  1650         TInt TerminalResponse( TDes8* aRsp );
       
  1651 
       
  1652 
       
  1653     private: // Data
       
  1654 
       
  1655         // Package allocated by an Etel client
       
  1656         RSat::TSetUpEventListV1Pckg*    iSetUpEventListV1Pckg;
       
  1657 
       
  1658         // Command qualifier
       
  1659         TUint8                          iCmdQualifier;
       
  1660 
       
  1661         // Event list
       
  1662         TUint                           iEvents;
       
  1663     };
       
  1664 
       
  1665 
       
  1666 /**
       
  1667 *  SAT PollingOff notification class.
       
  1668 *  Instantiated by CSatMessaging class.
       
  1669 *  This PCmd resets how often the ME shall send STATUS commands
       
  1670 *  related to Proactive Polling. The default value for reset is 25 seconds.
       
  1671 *  Does not require any interaction with the Symbian OS side, and has no impact
       
  1672 *  on the Etel SAT client.
       
  1673 *
       
  1674 *  @lib SIMATKTSY.lib
       
  1675 *  @since Series 60 Series60_2.6
       
  1676 */
       
  1677 class CSatNotifyPollingOff : public CSatNotificationsBase
       
  1678     {
       
  1679     public:  // Constructors and destructor
       
  1680 
       
  1681         /**
       
  1682         * C++ default constructor.
       
  1683         * @since NCP 5.0
       
  1684         * @param aSatMessHandler pointer to satmessagehandler class
       
  1685         * @param aSatMessaging pointer to satmessaging class
       
  1686         */
       
  1687         CSatNotifyPollingOff( CSatMessHandler* aSatMessHandler,
       
  1688             CTsySatMessaging* aSatMessaging );
       
  1689 
       
  1690         /**
       
  1691         * Destructor.
       
  1692         */
       
  1693         ~CSatNotifyPollingOff();
       
  1694 
       
  1695     public: // Methods from base classes
       
  1696 
       
  1697         /**
       
  1698         * From CSatNotificationsBase Handles PollingOff PCmd ISI message
       
  1699         * @since NCP 5.0
       
  1700         * @param aIsiMessage to received ISI message
       
  1701         * @return none
       
  1702         */
       
  1703         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1704 
       
  1705         /**
       
  1706         * From CSatNotificationsBase Notification request received from
       
  1707         * ETel client. Not used in this PCmd since there is no interaction
       
  1708         * required with Etel SAT client.
       
  1709         * @since NCP 5.0
       
  1710         * @param aReqHandle request handle from ETel
       
  1711         * @param aDataPtr pointer to parameter class
       
  1712         * @return none
       
  1713         */
       
  1714         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1715     };
       
  1716 
       
  1717 
       
  1718 /**
       
  1719 *  SAT LocalInfo notification class.
       
  1720 *  Instantiated by CSatMessaging class.
       
  1721 *  This PCmd instructs the SAT to provide local information. Some
       
  1722 *  of the subfunctionality do not require interaction with Etel.
       
  1723 *
       
  1724 *  @lib SIMATKTSY.lib
       
  1725 *  @since Series 60 Series60_2.6
       
  1726 */
       
  1727 class CSatNotifyLocalInfo : public CSatNotificationsBase
       
  1728     {
       
  1729     public:  // Constructors and destructor
       
  1730 
       
  1731         /**
       
  1732         * C++ default constructor.
       
  1733         * @since NCP 5.0
       
  1734         * @param aSatMessHandler pointer to satmessagehandler class
       
  1735         * @param aSatMessaging pointer to satmessaging class
       
  1736         */
       
  1737         CSatNotifyLocalInfo( CSatMessHandler* aSatMessHandler,
       
  1738             CTsySatMessaging* aSatMessaging );
       
  1739 
       
  1740         /**
       
  1741         * Destructor.
       
  1742         */
       
  1743         ~CSatNotifyLocalInfo();
       
  1744 
       
  1745 
       
  1746     public: // Methods from base classes
       
  1747 
       
  1748         /**
       
  1749         * From CSatNotificationsBase Handles LocalInfo PCmd ISI message
       
  1750         * @since NCP 5.0
       
  1751         * @param aIsiMessage received ISI message
       
  1752         * @return none
       
  1753         */
       
  1754         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1755 
       
  1756         /**
       
  1757         * From CSatNotificationsBase Notification request received from
       
  1758         * ETel client
       
  1759         * @since Series 60 Series60_2.6
       
  1760         * @param aReqHandle request handle from ETel
       
  1761         * @param aDataPtr pointer to parameter class
       
  1762         * @return none
       
  1763         */
       
  1764         void Notify( const TTsyReqHandle aReqHandle,
       
  1765                              TDes8* aDataPtr = NULL );
       
  1766 
       
  1767         /**
       
  1768         * From CSatNotificationsBase Handles the LocalInfo terminal response
       
  1769         * @since Series 60 Series60_2.6
       
  1770         * @param aRsp pointer to a descriptor containing the response structure
       
  1771         * @return status
       
  1772         */
       
  1773         TInt TerminalResponse( TDes8* aRsp = NULL );
       
  1774 
       
  1775 
       
  1776     public: // New methods
       
  1777 
       
  1778         /**
       
  1779         * From CSatNotificationsBase Handles the LocalInfo terminal response
       
  1780         * @since Series 60 Series60_2.6
       
  1781         * @param aClearSatus If true clear status
       
  1782         * @return TBool iLocalInfoIsOngoing
       
  1783         */
       
  1784         TBool Status( TBool aClearStatus = EFalse );
       
  1785 
       
  1786 
       
  1787     private: // Data
       
  1788 
       
  1789         // Package allocated by an Etel client
       
  1790         RSat::TLocalInfoV3Pckg* iLocalInfoV3Pckg;
       
  1791 
       
  1792         // Response package allocated by SimAtkTsy. In use when terminal
       
  1793         // response result and parameters are determined in SimAtkTsy.
       
  1794         RSat::TLocalInfoRspV3   iLocalInfoRspV3;
       
  1795 
       
  1796         // Flag
       
  1797         TBool                   iLocalInfoIsOngoing;
       
  1798     };
       
  1799 
       
  1800 
       
  1801 /**
       
  1802 *  SAT TimerManagement notification class.
       
  1803 *  Instantiated by CSatMessaging class.
       
  1804 *  This PCmd instructs the SAT to start one timer. Up to 8 timers.
       
  1805 *  Does not require any interaction with the Symbian OS side, and has no impact
       
  1806 *  on the Etel SAT client.
       
  1807 *
       
  1808 *  @lib SIMATKTSY.lib
       
  1809 *  @since Series 60 Series60_2.6
       
  1810 */
       
  1811 class CSatNotifyTimerMgmt : public CSatNotificationsBase
       
  1812     {
       
  1813     public:  // Constructors and destructor
       
  1814 
       
  1815         /**
       
  1816         * C++ default constructor.
       
  1817         * @since NCP 5.0
       
  1818         * @param aSatMessHandler pointer to satmessagehandler class
       
  1819         * @param aSatMessaging pointer to satmessaging class
       
  1820         */
       
  1821         CSatNotifyTimerMgmt( CSatMessHandler* aSatMessHandler,
       
  1822             CTsySatMessaging* aSatMessaging );
       
  1823 
       
  1824         /**
       
  1825         * Destructor.
       
  1826         */
       
  1827         ~CSatNotifyTimerMgmt();
       
  1828 
       
  1829     public: // Methods from base classes
       
  1830 
       
  1831         /**
       
  1832         * From CSatNotificationsBase Handles TimerManagement PCmd ISI message
       
  1833         * @since NCP 5.0
       
  1834         * @param aIsiMessage received ISI message
       
  1835         * @return none
       
  1836         */
       
  1837         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1838 
       
  1839         /**
       
  1840         * From CSatNotificationsBase Notification request received from
       
  1841         * ETel client. Not used in this PCmd since there is no interaction
       
  1842         * required with Etel SAT client.
       
  1843         * @since NCP 5.0
       
  1844         * @param aReqHandle request handle from ETel
       
  1845         * @param aDataPtr pointer to parameter class
       
  1846         * @return none
       
  1847         */
       
  1848         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1849 
       
  1850 
       
  1851     private:    // New methods
       
  1852         /**
       
  1853         * From CSatNotificationsBase Converts time to seconds
       
  1854         * @since Series 60 Series60_2.6
       
  1855         * @param aTime pointer to time data
       
  1856         * @return TUint32 time expressed in seconds
       
  1857         */
       
  1858         TUint32 ConvertToSeconds( TPtrC8 time );
       
  1859 
       
  1860 
       
  1861     private: // Data
       
  1862 
       
  1863         // Command qualifier
       
  1864         TUint8 iCmdQualifier;
       
  1865     };
       
  1866 
       
  1867 
       
  1868 /**
       
  1869 *  SAT MoreTime notification class.
       
  1870 *  Instantiated by CSatMessaging class.
       
  1871 *  This PCmd informs the SAT that the SIM needs more time.
       
  1872 *  Does not require any interaction with the Symbian OS side, and has no impact
       
  1873 *  on the Etel SAT client.
       
  1874 *
       
  1875 *  @lib SIMATKTSY.lib
       
  1876 *  @since Series 60 Series60_2.6
       
  1877 */
       
  1878 class CSatNotifyMoreTime : public CSatNotificationsBase
       
  1879     {
       
  1880     public:  // Constructors and destructor
       
  1881 
       
  1882         /**
       
  1883         * C++ default constructor.
       
  1884         * @since NCP 5.0
       
  1885         * @param aSatMessHandler pointer to satmessagehandler class
       
  1886         * @param aSatMessaging pointer to satmessaging class
       
  1887         */
       
  1888         CSatNotifyMoreTime( CSatMessHandler* aSatMessHandler,
       
  1889             CTsySatMessaging* aSatMessaging );
       
  1890 
       
  1891         /**
       
  1892         * Destructor.
       
  1893         */
       
  1894         ~CSatNotifyMoreTime();
       
  1895 
       
  1896 
       
  1897     public: // Methods from base classes
       
  1898 
       
  1899         /**
       
  1900         * From CSatNotificationsBase Handles MoreTime PCmd ISI message
       
  1901         * @since NCP 5.0
       
  1902         * @param aIsiMessage received ISI message
       
  1903         * @return none
       
  1904         */
       
  1905         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1906 
       
  1907         /**
       
  1908         * From CSatNotificationsBase Notification request received from
       
  1909         * ETel client. Not used in this PCmd since there is no interaction
       
  1910         * required with Etel SAT client.
       
  1911         * @since NCP 5.0
       
  1912         * @param aReqHandle request handle from ETel
       
  1913         * @param aDataPtr pointer to parameter class
       
  1914         * @return none
       
  1915         */
       
  1916         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  1917     };
       
  1918 
       
  1919 
       
  1920 /**
       
  1921 *  SAT LanguageNotification notification class.
       
  1922 *  Instantiated by CSatMessaging class.
       
  1923 *  The SIM shall use this PCmd to notify the ME about the language
       
  1924 *  currently used for any text string within proactive commands or
       
  1925 *  envelope command responses.
       
  1926 *
       
  1927 *  @lib SIMATKTSY.lib
       
  1928 *  @since Series 60 Series60_2.6
       
  1929 */
       
  1930 class CSatNotifyLanguageNotification : public CSatNotificationsBase
       
  1931     {
       
  1932     public:  // Constructors and destructor
       
  1933 
       
  1934         /**
       
  1935         * C++ default constructor.
       
  1936         * @since NCP 5.0
       
  1937         * @param aSatMessHandler pointer to satmessagehandler class
       
  1938         * @param aSatMessaging pointer to satmessaging class
       
  1939         */
       
  1940         CSatNotifyLanguageNotification( CSatMessHandler* aSatMessHandler,
       
  1941             CTsySatMessaging* aSatMessaging );
       
  1942 
       
  1943         /**
       
  1944         * Destructor.
       
  1945         */
       
  1946         ~CSatNotifyLanguageNotification();
       
  1947 
       
  1948 
       
  1949     public: // Methods from base classes
       
  1950 
       
  1951         /**
       
  1952         * From CSatNotificationsBase Handles LanguageNotification PCmd
       
  1953         * ISI message
       
  1954         * @since NCP 5.0
       
  1955         * @param aIsiMessage received ISI message
       
  1956         * @return none
       
  1957         */
       
  1958         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  1959 
       
  1960         /**
       
  1961         * From CSatNotificationsBase Notification request received from
       
  1962         * ETel client
       
  1963         * @since Series 60 Series60_2.6
       
  1964         * @param aReqHandle request handle from ETel
       
  1965         * @param aDataPtr pointer to parameter class
       
  1966         * @return none
       
  1967         */
       
  1968         void Notify( const TTsyReqHandle aReqHandle,
       
  1969                              TDes8* aDataPtr = NULL );
       
  1970 
       
  1971         /**
       
  1972         * From CSatNotificationsBase Handles the LanguageNotification
       
  1973         * terminal response
       
  1974         * @since Series 60 Series60_2.6
       
  1975         * @param aRsp pointer to a descriptor containing the response structure
       
  1976         * @return status
       
  1977         */
       
  1978         TInt TerminalResponse( TDes8* aRsp );
       
  1979 
       
  1980 
       
  1981     private: //Data
       
  1982 
       
  1983         // Package allocated by an Etel client
       
  1984         RSat::TLanguageNotificationV2Pckg*  iLanguageNotificationV2Pckg;
       
  1985     };
       
  1986 
       
  1987 
       
  1988 /**
       
  1989 *  SAT OpenChannel notification class.
       
  1990 *  Instantiated by CSatMessaging class.
       
  1991 *  This PCmd instructs the SAT to open either GPRS channel, or a CSD channel
       
  1992 *  or a local link channel, exclusively.
       
  1993 *
       
  1994 *  @lib SIMATKTSY.lib
       
  1995 *  @since Series 60 Series60_3.0
       
  1996 */
       
  1997 class CSatNotifyOpenChannel : public CSatNotificationsBase
       
  1998     {
       
  1999     public:  // Constructors and destructor
       
  2000 
       
  2001         /**
       
  2002         * C++ default constructor.
       
  2003         * @since NCP 5.0
       
  2004         * @param aSatMessHandler pointer to satmessagehandler class
       
  2005         * @param aSatMessaging pointer to satmessaging class
       
  2006         */
       
  2007         CSatNotifyOpenChannel( CSatMessHandler* aSatMessHandler,
       
  2008             CTsySatMessaging* aSatMessaging );
       
  2009 
       
  2010         /**
       
  2011         * Destructor.
       
  2012         */
       
  2013         ~CSatNotifyOpenChannel();
       
  2014 
       
  2015 
       
  2016     public: // Methods from base classes
       
  2017 
       
  2018         /**
       
  2019         * From CSatNotificationsBase Handles OpenChannel PCmd ISI message
       
  2020         * @since NCP 5.0
       
  2021         * @param aIsiMessage received ISI message
       
  2022         * @return none
       
  2023         */
       
  2024         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  2025 
       
  2026         /**
       
  2027         * From CSatNotificationsBase Notification request received from
       
  2028         * ETel client
       
  2029         * @since Series 60 Series60_2.6
       
  2030         * @param aReqHandle request handle from ETel
       
  2031         * @param aDataPtr pointer to parameter class
       
  2032         * @return none
       
  2033         */
       
  2034         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2035 
       
  2036         /**
       
  2037         * From CSatNotificationsBase Handles the OpenChannel terminal response
       
  2038         * @since Series 60 Series60_2.6
       
  2039         * @param aRsp pointer to a descriptor containing the response structure
       
  2040         * @return status
       
  2041         */
       
  2042         TInt TerminalResponse( TDes8* aRsp );
       
  2043 
       
  2044         /**
       
  2045         * From CSatNotificationsBase Handles Bearer type and parameters data
       
  2046         * @since PP 5.2
       
  2047         * @param aBearerDescriptionTlv tlv containing specific data
       
  2048         * @param aBearer bearer structure
       
  2049         * @return none
       
  2050         */
       
  2051         void GetBearerTypeAndParams( CTlv& aBearerDescriptionTlv,
       
  2052             RSat::TBearer& aBearer );
       
  2053 
       
  2054         /**
       
  2055         * From CSatNotificationsBase Handles SIM/ME Interface transport level and
       
  2056         * Data Destination Address specific data
       
  2057         * @since PP 5.2
       
  2058         * @param aBerTlv tlv containing specific data
       
  2059         * @param aSimMeInterface SIM/ME interface structure
       
  2060         * @param aDestinationAddress Data Destination address structure
       
  2061         * @return KErrNone or KErrNotFound
       
  2062         */
       
  2063         TInt SimMeInterfaceAndDataDestinationAddress( CBerTlv& aBerTlv,
       
  2064             RSat::TSimMeInterface& aSimMeInterface,
       
  2065             RSat::TOtherAddress& aDestinationAddress );
       
  2066 
       
  2067         /**
       
  2068         * From CSatNotificationsBase Handles Local Address specific data
       
  2069         * @since PP 5.2
       
  2070         * @param aBerTlv tlv containing specific data
       
  2071         * @param aLocalAddress Local address structure
       
  2072         * @return none
       
  2073         */
       
  2074         void LocalAddress( CBerTlv& aBerTlv,
       
  2075             RSat::TOtherAddress& aLocalAddress );
       
  2076 
       
  2077         /**
       
  2078         * From CSatNotificationsBase Handles the OpenChannel GPRS Bearer
       
  2079         * specific data
       
  2080         * @since PP 5.2
       
  2081         * @param aBerTlv tlv containing Bearer specific data
       
  2082         * @param RSat::TOpenGprsChannelV4& aOpenGprsChannelV4 data
       
  2083         * @return none
       
  2084         */
       
  2085         void GprsBearerSpecific( CBerTlv& aBerTlv,
       
  2086             RSat::TOpenGprsChannelV4& aOpenGprsChannelV4 );
       
  2087 
       
  2088     private: // Data
       
  2089 
       
  2090         // Packages allocated by ETel:
       
  2091 
       
  2092         // Base class
       
  2093         RSat::TOpenChannelBaseV2Pckg*       iOpenBaseChannelV2Pckg;
       
  2094 
       
  2095         // Open Cs Channel package store
       
  2096         RSat::TOpenCsChannelV2Pckg*         iOpenCsChannelV2Pckg;
       
  2097 
       
  2098         // Open Gprs Channel package store
       
  2099         RSat::TOpenGprsChannelV4Pckg*       iOpenGprsChannelV4Pckg;
       
  2100 
       
  2101         // Open Local Link Channel package store
       
  2102         RSat::TOpenLocalLinksChannelV2Pckg* iOpenLocalLinksChannelV2Pckg;
       
  2103     };
       
  2104 
       
  2105 
       
  2106 /**
       
  2107 *  SAT GetChannelStatus notification class.
       
  2108 *  Instantiated by CSatMessaging class.
       
  2109 *  This PCmd instructs the SAT to tell the SIM about a channel status specified
       
  2110 *  in the PCmd.
       
  2111 *
       
  2112 *  @lib SIMATKTSY.lib
       
  2113 *  @since Series 60 Series60_3.0
       
  2114 */
       
  2115 class CSatNotifyGetChannelStatus : public CSatNotificationsBase
       
  2116     {
       
  2117     public:  // Constructors and destructor
       
  2118 
       
  2119         /**
       
  2120         * C++ default constructor.
       
  2121         * @since NCP 5.0
       
  2122         * @param aSatMessHandler pointer to satmessagehandler class
       
  2123         * @param aSatMessaging pointer to satmessaging class
       
  2124         */
       
  2125         CSatNotifyGetChannelStatus( CSatMessHandler* aSatMessHandler,
       
  2126             CTsySatMessaging* aSatMessaging );
       
  2127 
       
  2128         /**
       
  2129         * Destructor.
       
  2130         */
       
  2131         ~CSatNotifyGetChannelStatus();
       
  2132 
       
  2133 
       
  2134     public: // Methods from base classes
       
  2135 
       
  2136         /**
       
  2137         * From CSatNotificationsBase Handles GetChannelStatus PCmd ISI message
       
  2138         * @since NCP 5.0
       
  2139         * @param aIsiMessage received ISI message
       
  2140         * @return none
       
  2141         */
       
  2142         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  2143 
       
  2144         /**
       
  2145         * From CSatNotificationsBase Notification request received from
       
  2146         * ETel client
       
  2147         * @since Series 60 Series60_2.6
       
  2148         * @param aReqHandle request handle from ETel
       
  2149         * @param aDataPtr pointer to parameter class
       
  2150         * @return none
       
  2151         */
       
  2152         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2153 
       
  2154         /**
       
  2155         * From CSatNotificationsBase Handles the GetChannelStatus
       
  2156         * terminal response
       
  2157         * @since Series 60 Series60_2.6
       
  2158         * @param aRsp pointer to a descriptor containing the response structure
       
  2159         * @return status
       
  2160         */
       
  2161         TInt TerminalResponse( TDes8* aRsp );
       
  2162 
       
  2163 
       
  2164     private: // Data
       
  2165 
       
  2166         // Package allocated by an Etel client
       
  2167         RSat::TGetChannelStatusV2Pckg* iGetChannelStatusRspV2Pckg;
       
  2168     };
       
  2169 
       
  2170 
       
  2171 /**
       
  2172 *  SAT CloseChannel notification class.
       
  2173 *  Instantiated by CSatMessaging class.
       
  2174 *  This PCmd instructs the SAT to close either GPRS channel, or a CSD channel
       
  2175 *  or a local link channel, exclusively.
       
  2176 *
       
  2177 *  @lib SIMATKTSY.lib
       
  2178 *  @since Series 60 Series60_3.0
       
  2179 */
       
  2180 class CSatNotifyCloseChannel : public CSatNotificationsBase
       
  2181     {
       
  2182     public:  // Constructors and destructor
       
  2183 
       
  2184         /**
       
  2185         * C++ default constructor.
       
  2186         * @since NCP 5.0
       
  2187         * @param aSatMessHandler pointer to satmessagehandler class
       
  2188         * @param aSatMessaging pointer to satmessaging class
       
  2189         */
       
  2190         CSatNotifyCloseChannel( CSatMessHandler* aSatMessHandler,
       
  2191             CTsySatMessaging* aSatMessaging );
       
  2192 
       
  2193         /**
       
  2194         * Destructor.
       
  2195         */
       
  2196         ~CSatNotifyCloseChannel();
       
  2197 
       
  2198 
       
  2199     public: // Methods from base classes
       
  2200 
       
  2201         /**
       
  2202         * From CSatNotificationsBase Handles CloseChannel PCmd ISI message
       
  2203         * @since NCP 5.0
       
  2204         * @param aIsiMessage received ISI message
       
  2205         * @return none
       
  2206         */
       
  2207         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  2208 
       
  2209         /**
       
  2210         * From CSatNotificationsBase Notification request received from
       
  2211         * ETel client
       
  2212         * @since Series 60 Series60_2.6
       
  2213         * @param aReqHandle request handle from ETel
       
  2214         * @param aDataPtr pointer to parameter class
       
  2215         * @return none
       
  2216         */
       
  2217         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2218 
       
  2219         /**
       
  2220         * From CSatNotificationsBase Handles the CloseChannel terminal response
       
  2221         * @since Series 60 Series60_2.6
       
  2222         * @param aRsp pointer to a descriptor containing the response structure
       
  2223         * @return status
       
  2224         */
       
  2225         TInt TerminalResponse( TDes8* aRsp );
       
  2226 
       
  2227 
       
  2228     private: // Data
       
  2229 
       
  2230         // Package allocated by an Etel client
       
  2231         RSat::TCloseChannelV2Pckg*  iCloseChannelRspV2Pckg;
       
  2232     };
       
  2233 
       
  2234 
       
  2235 /**
       
  2236 *  SAT SendData notification class.
       
  2237 *  Instantiated by CSatMessaging class.
       
  2238 *  This PCmd instructs the SAT to send data through either GPRS channel,
       
  2239 *  or a CSD channel or a local link channel, exclusively.
       
  2240 *
       
  2241 *  @lib SIMATKTSY.lib
       
  2242 *  @since Series 60 Series60_3.0
       
  2243 */
       
  2244 class CSatNotifySendData : public CSatNotificationsBase
       
  2245     {
       
  2246     public:  // Constructors and destructor
       
  2247 
       
  2248         /**
       
  2249         * C++ default constructor.
       
  2250         * @since NCP 5.0
       
  2251         * @param aSatMessHandler pointer to satmessagehandler class
       
  2252         * @param aSatMessaging pointer to satmessaging class
       
  2253         */
       
  2254         CSatNotifySendData( CSatMessHandler* aSatMessHandler,
       
  2255             CTsySatMessaging* aSatMessaging );
       
  2256 
       
  2257         /**
       
  2258         * Destructor.
       
  2259         */
       
  2260         ~CSatNotifySendData();
       
  2261 
       
  2262 
       
  2263     public: // Methods from base classes
       
  2264 
       
  2265         /**
       
  2266         * From CSatNotificationsBase Handles SendData PCmd ISI message
       
  2267         * @since NCP 5.0
       
  2268         * @param aIsiMessage received ISI message
       
  2269         * @return none
       
  2270         */
       
  2271         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  2272 
       
  2273         /**
       
  2274         * From CSatNotificationsBase Notification request received from
       
  2275         * ETel client
       
  2276         * @since Series 60 Series60_2.6
       
  2277         * @param aReqHandle request handle from ETel
       
  2278         * @param aDataPtr pointer to parameter class
       
  2279         * @return none
       
  2280         */
       
  2281         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2282 
       
  2283         /**
       
  2284         * From CSatNotificationsBase Handles the SendData terminal response
       
  2285         * @since Series 60 Series60_2.6
       
  2286         * @param aRsp pointer to a descriptor containing the response structure
       
  2287         * @return status
       
  2288         */
       
  2289         TInt TerminalResponse( TDes8* aRsp );
       
  2290 
       
  2291 
       
  2292     private: // Data
       
  2293 
       
  2294         // Package allocated by an Etel client
       
  2295         RSat::TSendDataV2Pckg*  iSendDataRspV2Pckg;
       
  2296     };
       
  2297 
       
  2298 
       
  2299 /**
       
  2300 *  SAT ReceiveData notification class.
       
  2301 *  Instantiated by CSatMessaging class.
       
  2302 *  This PCmd instructs the SAT to receive data either from GPRS channel,
       
  2303 *  or a CSD channel or a local link channel, exclusively.
       
  2304 *
       
  2305 *  @lib SIMATKTSY.lib
       
  2306 *  @since Series 60 Series60_3.0
       
  2307 */
       
  2308 class CSatNotifyReceiveData : public CSatNotificationsBase
       
  2309     {
       
  2310     public:  // Constructors and destructor
       
  2311 
       
  2312         /**
       
  2313         * C++ default constructor.
       
  2314         * @since NCP 5.0
       
  2315         * @param aSatMessHandler pointer to satmessagehandler class
       
  2316         * @param aSatMessaging pointer to satmessaging class
       
  2317         */
       
  2318         CSatNotifyReceiveData( CSatMessHandler* aSatMessHandler,
       
  2319             CTsySatMessaging* aSatMessaging );
       
  2320 
       
  2321         /**
       
  2322         * Destructor.
       
  2323         */
       
  2324         ~CSatNotifyReceiveData();
       
  2325 
       
  2326 
       
  2327     public: // Methods from base classes
       
  2328 
       
  2329         /**
       
  2330         * From CSatNotificationsBase Handles ReceiveData PCmd ISI message
       
  2331         * @since NCP 5.0
       
  2332         * @param aIsiMessage received ISI message
       
  2333         * @return none
       
  2334         */
       
  2335         void MessageReceived( const TIsiReceiveC& aIsiMessage );
       
  2336 
       
  2337         /**
       
  2338         * From CSatNotificationsBase Notification request received from
       
  2339         * ETel client
       
  2340         * @since Series 60 Series60_2.6
       
  2341         * @param aReqHandle request handle from ETel
       
  2342         * @param aDataPtr pointer to parameter class
       
  2343         * @return none
       
  2344         */
       
  2345         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2346 
       
  2347         /**
       
  2348         * From CSatNotificationsBase Handles the ReceiveData terminal response
       
  2349         * @since Series 60 Series60_2.6
       
  2350         * @param aRsp pointer to a descriptor containing the response structure
       
  2351         * @return status
       
  2352         */
       
  2353         TInt TerminalResponse( TDes8* aRsp );
       
  2354 
       
  2355 
       
  2356     private: // Data
       
  2357 
       
  2358         // Package allocated by an Etel client
       
  2359         RSat::TReceiveDataV2Pckg*   iReceiveDataRspV2Pckg;
       
  2360     };
       
  2361 
       
  2362 
       
  2363 /**
       
  2364 *  SAT MoSmControlRequest notification class.
       
  2365 *  Instantiated by CSatMessaging class.
       
  2366 *  MoSmControlRequest is not treated as a proactive command in Series60.
       
  2367 *  The method CompleteNotification is used to notify an Etel SAT client
       
  2368 *  that the SIM Applet has provided an alpha identifier in response to
       
  2369 *  a CallControl envelope. The class CSatMoSmsCtrl implements the MoSmControl
       
  2370 *  functionality.
       
  2371 *
       
  2372 *  @lib SIMATKTSY.lib
       
  2373 *  @since Series 60 Series60_2.6
       
  2374 */
       
  2375 class CSatNotifyMoSmControlRequest : public CSatNotificationsBase
       
  2376     {
       
  2377     public:  // Constructors and destructor
       
  2378 
       
  2379         /**
       
  2380         * C++ default constructor.
       
  2381         * @since NCP 5.0
       
  2382         * @param aSatMessHandler pointer to satmessagehandler class
       
  2383         * @param aSatMessaging pointer to satmessaging class
       
  2384         */
       
  2385         CSatNotifyMoSmControlRequest( CSatMessHandler* aSatMessHandler,
       
  2386             CTsySatMessaging* aSatMessaging );
       
  2387 
       
  2388         /**
       
  2389         * Destructor.
       
  2390         */
       
  2391         ~CSatNotifyMoSmControlRequest();
       
  2392 
       
  2393 
       
  2394     public: // Methods from base classes
       
  2395 
       
  2396         /**
       
  2397         * From CSatNotificationsBase Handles MoSmControlRequest PCmd ISI message
       
  2398         * Not in use.
       
  2399         * @since NCP 5.0
       
  2400         * @param aIsiMessage received ISI message
       
  2401         * @return none
       
  2402         */
       
  2403         void MessageReceived( const TIsiReceiveC& /*aIsiMessage*/ );
       
  2404 
       
  2405         /**
       
  2406         * From CSatNotificationsBase Notification request received from
       
  2407         * ETel client
       
  2408         * @since Series 60 Series60_2.6
       
  2409         * @param aReqHandle request handle from ETel
       
  2410         * @param aDataPtr pointer to parameter class
       
  2411         * @return none
       
  2412         */
       
  2413         void Notify( const TTsyReqHandle aReqHandle, TDes8* aDataPtr = NULL );
       
  2414 
       
  2415         /**
       
  2416         * From CSatNotificationsBase Notification completion
       
  2417         * @since Series 60 Series60_2.6
       
  2418         * @param aAlphaId alpha identifier in Etel SAT format
       
  2419         * @param aResult call control result in Etel SAT format
       
  2420         * @return none
       
  2421         */
       
  2422         void CompleteNotification( TDesC& aAlphaId,
       
  2423             RSat::TControlResult aResult );
       
  2424 
       
  2425 
       
  2426     private: // Data
       
  2427 
       
  2428         // Package allocated by an Etel client
       
  2429         RSat::TMoSmControlV1Pckg*   iMoSmControlV1Pckg;
       
  2430     };
       
  2431 
       
  2432 #endif // SATNOTIFICATIONS_H
       
  2433 
       
  2434 // End of File