1 /*

     2 * Copyright (c) 2006-2009 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 "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 CMMPACKETCONTEXTTSY_H

    21 #define CMMPACKETCONTEXTTSY_H

    22 

    23 //  INCLUDES

    24 #include "Cmmpacketservicetsy.h"

    25 #include "cmmpacketcontextgsmwcdmaext.h"

    26 #include "Cmmpacketqostsy.h"

    27 

    28 // FORWARD DECLARATIONS

    29 class CMmTsyReqHandleStore;

    30 class CMmPacketQoSTsy;

    31 class CMmPacketServiceTsy;

    32 class CMmPacketContextGsmWcdmaExt;

    33 

    34 // CLASS DECLARATION

    35 

    36 /**

    37 *  CMmPacketContextTsy contains GPRS context related functionality. 

    38 */

    39 NONSHARABLE_CLASS( CMmPacketContextTsy ) : public CSubSessionExtBase

    40     {

    41     public: // Constructor and destructor    

    42 

    43         /**

    44          * The type of the context

    45          */

    46     	enum TPacketContextType

    47             {

    48             /**

    49              * Packet Context

    50              */

    51             EContextTypePacketContext,

    52             /**

    53              * MBMS Context

    54              */

    55             EContextTypeMBMS

    56             };    

    57 

    58         /**

    59          * NewL method is used to create a new instance of CMmPacketContextTsy

    60          * class.

    61          * 

    62          *                  

    63          * @param aMmPacketService Pointer to the Packet Service object

    64          * @param aHostCID Name of existing context

    65          * @param aName Context name

    66          * @param aMessageManager Pointer to the Message Manager object

    67          * @param aProxyId Proxy id

    68          */

    69         static CMmPacketContextTsy* NewL

    70                 (

    71                 CMmPacketServiceTsy* const aMmPacketService,

    72                 const TInfoName& aHostCID,

    73                 const TDes& aName,

    74                 const TUint8 aProxyId = 0x00

    75                 );

    76 

    77         /**

    78          * Destructor

    79          */

    80         ~CMmPacketContextTsy();

    81 

    82         /**

    83          * Initialisation method that is called from ETel Server.

    84          *         

    85          *

    86          */

    87         virtual void Init();

    88 

    89         /**

    90          * TRAP's all CMmPacketContextTsy related MM API requests in case that

    91          * they fail. This method functions only as a centralized TRAP for the

    92          * DoExtFuncL method that does the actual mapping of IPC number to

    93          * TSY method call.

    94          *         

    95          *

    96          * @param aTsyReqHandle TSY request handle from ETel server

    97          * @param aIpc IPC number of the request

    98          * @param aPackage Reference to the input parameters.

    99          * @return KErrNone/KErrNotSupported

   100          */

   101         virtual TInt ExtFunc( const TTsyReqHandle aTsyReqHandle, 

   102             const TInt aIpc, const TDataPackage& aPackage );    

   103 

   104         /**

   105          * Returns request mode for given IPC number

   106          *          

   107          *         *         

   108          * @param aIpc IPC number of the request

   109          * @return CTelObject::TReqMode Request mode

   110          */

   111         virtual CTelObject::TReqMode ReqModeL( const TInt aIpc );

   112 

   113         /**

   114          * Returns number of slots to be used for a given IPC

   115          *          

   116          *         *         

   117          * @param aIpc IPC number of the request

   118          * @return TInt Number of slots for this request

   119          */

   120         virtual TInt NumberOfSlotsL( const TInt aIpc );

   121 

   122         /**

   123          * Cancels request that's IPC number and request handle are given as

   124          * parameters

   125          *         

   126          *   

   127          * @param aIpc: IPC number of the request

   128          * @param aTsyReqHandle Request handle from ETel server

   129          * @return KErrNone/KErrNotSupported

   130          */

   131         virtual TInt CancelService( const TInt aIpc, 

   132             const TTsyReqHandle aTsyReqHandle );

   133 

   134         /**

   135          * Register given notification

   136          *         

   137          *

   138          * @param aIpc IPC number of the request

   139          * @return TInt Result of the request

   140          */

   141         virtual TInt RegisterNotification( const TInt aIpc );

   142 

   143         /**

   144          * Deregister given notification

   145          *         

   146          *

   147          * @param aIpc IPC number of the request

   148          * @return TInt Result of the request

   149          */

   150         virtual TInt DeregisterNotification( const TInt aIpc );

   151     

   152         /**

   153          * Create new QoS object and returns a pointer to it

   154          *         

   155          *

   156          * @return aName On return contains the name of opened object

   157          * @return CTelObject* Opened object 

   158          */

   159         virtual CTelObject* OpenNewObjectL( TDes& aNewName );

   160 

   161         /**

   162          * Return a pointer to QoS if it exists

   163          *         

   164          *

   165          * @param aName Object name that should be opened

   166          * @return CTelObject* Opened object 

   167          */

   168         virtual CTelObject* OpenNewObjectByNameL( const TDesC& aName );

   169 

   170         /**

   171          * Complete the context initialisation

   172          *         

   173          *

   174          * @param aResult Result of the request

   175          */

   176         void CompleteInitialiseContext( const TInt aResult );

   177 

   178         /**

   179          * Complete the context activation.

   180          *         

   181          *

   182          * @param aResult Result of the request

   183          */

   184         void CompleteActivate( const TInt aResult );

   185 

   186         /**

   187          * Complete the context deactivation

   188          *         

   189          *

   190          * @param aResult Result of the request

   191          */

   192         void CompleteDeactivate( const TInt aResult );

   193  

   194         /**

   195          * Complete the context delete

   196          *         

   197          *

   198          * @param aResult Result of the request

   199          */

   200         void CompleteDelete( const TInt aResult );

   201 

   202         /**

   203          * Complete the config changed notification

   204          *         

   205          *

   206          * @param aResult Result of the request

   207          */

   208         void CompleteNotifyConfigChanged();

   209         

   210         /**

   211          * Complete the connection speed change notification

   212          *         

   213          *

   214          * @param aConnectionSpeed Contains connections speed

   215          */

   216         virtual void CompleteNotifyConnectionSpeedChange(

   217             TInt const aConnectionSpeed );

   218         

   219         /**

   220          * Complete the status change notification

   221          *         

   222          *

   223          * @param aContextStatus Contains status of the context

   224          */

   225         void CompleteNotifyStatusChange(

   226             const RPacketContext::TContextStatus aContextStatus );

   227         

   228         /**

   229          * Complete the context configuration

   230          *         

   231          *

   232          * @param aResult Result of the request

   233          * @param aIsAddMediaAuthorizationCalled indicator to check if

   234          *        Response is for AddMediaAuthorizationL

   235          */

   236         void CompleteSetConfig( const TInt aResult,

   237                         TBool aIsAddMediaAuthorizationCalled = EFalse );

   238 

   239         /**

   240          * Complete the get data volume transferred request.

   241          *         

   242          *

   243          * @param aResult Result of the request

   244          */

   245         void CompleteGetDataVolumeTransferred( const TInt aResult );

   246 

   247         /**

   248          * Sets the amount of data transmitted & received over the

   249          * airlink since the context was activated. 

   250          *         

   251          *

   252          * @param aResult Contains context configuration

   253          * @param dataVolume Contains transmitted & received data

   254          */

   255         virtual void SetDataVolume( const TInt aResult,

   256             RPacketContext::TDataVolume dataVolume );

   257 

   258         /**

   259          * Set the last error cause.

   260          *         

   261          *

   262          * @param aErrorCause Contains the last error cause

   263          */

   264         void SetLastErrorCause( const TInt aErrorCause );

   265 

   266         /**

   267          * Get the context status.

   268          *         

   269          *

   270          * return RPacketContext::TContextStatus

   271          */

   272         RPacketContext::TContextStatus ContextStatus() const;

   273 

   274         /**

   275          * Suspend the context. Called from Packet Service Tsy to notify client

   276          *         

   277          *

   278          */

   279         void ContextSuspended();

   280 

   281         /**

   282          * Resume the suspended context. This function is called from 

   283          * Packet Service Tsy to notify client

   284          *         

   285          *

   286          */

   287         void ContextResumed();

   288 

   289         /**

   290          * Return a pointer to CMmPacketContextGsmWcdmaExt

   291          *         

   292          *

   293          * @return Pointer to extension

   294          */

   295         virtual CMmPacketContextGsmWcdmaExt* PacketContextGsmWcdmaExt() const;

   296 

   297         /**

   298          * Return a pointer to CMmPacketQoSTsy

   299          *         

   300          *

   301          * @return CMmPacketQoSTsy* Pointer 

   302          */

   303         CMmPacketQoSTsy* PacketQoSTsy() const;

   304 

   305         /**

   306          * Remove a pointer to CMmPacketQoSTsy

   307          *         

   308          *

   309          */

   310         void RemoveQoS();

   311 

   312         /**

   313          * Check if this is a dial-up context, otherwise EFalse.

   314          *         

   315          *

   316          * @param aContextName Contains the name of this context

   317          * @return TBool ETrue/EFalse

   318          */

   319         TBool IsDialUpContext( const TInfoName* const aContextName = NULL

   320             ) const;

   321 

   322         /**

   323          * Return the HostCID class member

   324          *         

   325          *

   326          * @return TInfoName iHostCID containing host context name or none

   327          */

   328         TInfoName HostCID() const;

   329 

   330         /**

   331          * Completes contecxt Modification to client.

   332          *         

   333          *

   334          * @param aResult Result of the request

   335          */

   336         void CompleteModifyActiveContext( const TInt aResult );

   337 

   338         /**

   339          * Return the contextName

   340          *         

   341          *

   342          * @return TInfoName iContextName containing context name

   343          */

   344         TInfoName ContextName() const;

   345 

   346         /**

   347          * Reset the externally created dial-up context.

   348          *         

   349          *

   350          */

   351         void ResetDialUpContext();

   352         

   353         /** 

   354          * C++ default constructor.

   355          */

   356         CMmPacketContextTsy();

   357         

   358 

   359         /**

   360          * Returns type of context based on context name

   361          *

   362          * @param aInfoName Name of the context

   363          * @return TInt Type of context

   364          */

   365         virtual TPacketContextType ContextType() const;

   366 

   367 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   368         /**

   369          * Completes connection information change notification to the client and

   370          * updates new connection info to CTSY cache if information is changed.

   371          *         

   372          *

   373          * @param aDataPackage: new connection information

   374          */

   375         void CompleteNotifyConnectionInfoChange(

   376             TConnectionInfoBase* const aInfo );    

   377 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   378 

   379 #ifdef REQHANDLE_TIMER

   380         /**

   381          * Call the needed complete method due the timer expiration.

   382          *         

   383          *

   384          * @param aReqHandleType  

   385          * @param aError                      

   386          */

   387         void Complete

   388                 (

   389                 const TInt aReqHandleType,

   390                 const TInt aError 

   391                 );

   392 #endif //REQHANDLE_TIMER

   393 

   394     private: // New functions

   395       

   396 

   397     

   398         /**

   399          * Class attributes are created in ConstructL.

   400          */

   401         void ConstructL();

   402 

   403         /**

   404          * Initialises extension modules for CMmPacketContextTsy.

   405          * 

   406          *                

   407          */

   408         void InitModulesL();

   409 

   410         /**

   411          * Initialise miscellaneous internal attributes.

   412          * 

   413          *                

   414          */

   415         void InitInternalAttributes();

   416         

   417         /**

   418          * TRAP's all CMmPacketContextTsy related MM Packet API requests in 

   419          * case that they fail. This method functions only as a centralized

   420          * TRAP for the DoExtFuncL method that does the actual mapping of IPC 

   421          * number to TSY method call.

   422          *         

   423          *

   424          * @param aTsyReqHandle TSY request handle from ETel server

   425          * @param aIpc IPC number of the request

   426          * @param aPackage Reference to the input parameters.

   427          * @return KErrNone/KErrNotSupported

   428          */

   429         TInt DoExtFuncL( const TTsyReqHandle aTsyReqHandle,

   430             const TInt aIpc, const TDataPackage& aPackage );

   431 

   432         /**

   433          * Initialise a context

   434          *

   435          * @param aDataChannel to be populated and returned to client  

   436          * @return TInt Success/failure value

   437          */

   438         TInt InitialiseContextL(RPacketContext::TDataChannelV2* aDataChannel);

   439         

   440         /**

   441          * Activate a context

   442          *         

   443          *

   444          * @return TInt Success/failure value

   445          */

   446         TInt ActivateL();

   447 

   448         /**

   449          * Deactivate a context

   450          *         

   451          *

   452          * @return TInt Success/failure value

   453          */

   454         TInt DeactivateL();

   455 

   456         /**

   457          * Deletes a context

   458          *         

   459          *

   460          * @return TInt Success/failure value

   461          */

   462         TInt DeleteL();

   463     

   464         /**

   465          * Get the context configuration info

   466          *         

   467          *

   468          * @param aTsyReqHandle TSY request handle

   469          * @return aConfig Contains Context configuration info on return

   470          * @return TInt Success/failure value

   471          */

   472         TInt GetConfig( const TTsyReqHandle aTsyReqHandle,

   473             TPacketDataConfigBase* const aConfig );

   474 

   475         /**

   476          * Get the current connection speed availability

   477          *         

   478          *

   479          * @param aTsyReqHandle TSY request handle

   480          * @return aRate Contains connection speed on return

   481          * @return TInt Success/failure value

   482          */

   483         TInt GetConnectionSpeed( const TTsyReqHandle aTsyReqHandle,

   484             TUint* const aRate );

   485 

   486         /**

   487          * Get the data volume transferred

   488          *         

   489          *

   490          * @param aTsyReqHandle TSY request handle

   491          * @return aVolume Contains data volume transferred on return

   492          * @return TInt Success/failure value

   493          */

   494         TInt GetDataVolumeTransferredL( const TTsyReqHandle aTsyReqHandle,

   495             RPacketContext::TDataVolume* const aVolume );

   496 

   497         /**

   498          * Get the last error cause occurred

   499          *         

   500          *

   501          * @param aTsyReqHandle TSY request handle

   502          * @return aError Contains last error value on return

   503          * @return TInt Success/failure value

   504          */

   505         TInt GetLastErrorCause( const TTsyReqHandle aTsyReqHandle,

   506             TInt* const aError );

   507 

   508         /**

   509          * Get the QoS profile name

   510          *         

   511          *

   512          * @param aTsyReqHandle TSY request handle

   513          * @return aQoSProfile Contains QoS profile name on return

   514          * @return TInt Success/failure value

   515          */

   516         TInt GetProfileName( const TTsyReqHandle aTsyReqHandle,

   517             TInfoName* const aQoSProfile );

   518 

   519         /**

   520          * Get the current status of the context

   521          *         

   522          *

   523          * @param aTsyReqHandle TSY request handle

   524          * @return aContextStatus Contains current status of the context

   525          * @return TInt KErrNone

   526          */

   527         TInt GetStatus( const TTsyReqHandle aTsyReqHandle,

   528             RPacketContext::TContextStatus* const aContextStatus );

   529 

   530         /**

   531          * Allows clients to be notified of any change in context 

   532          * configuration. Allows a client to be notified whenever a change in 

   533          * the configuration of the current context is detected and passes 

   534          * back the updated  configuration. Note that once the notification 

   535          * completes, the clients must then re-post the notification if they 

   536          * wish to continue receiving the notification.

   537          *         

   538          *

   539          * @return aConfig Contains context configuration info on return

   540          * @return TInt Success/failure value

   541          */

   542         TInt NotifyConfigChanged( TPacketDataConfigBase* const aConfig );

   543 

   544         /**

   545          * Allows clients to be notified of any change in the connection speed

   546          *

   547          *         

   548          * @return aRate Contains the connection speed on return

   549          * @return TInt Success/failure value

   550          */

   551         TInt NotifyConnectionSpeedChange( TUint* const aRate );

   552 

   553         /**

   554          * Allows clients to be notified of any change in the context status

   555          *

   556          *         

   557          * @return aContextStatus Contains the status of the context on return

   558          * @return TInt Success/failure value

   559          */

   560         TInt NotifyStatusChange( RPacketContext::TContextStatus* const

   561             aContextStatus );

   562 

   563         

   564         /**

   565          * Set context configuration

   566          *

   567          *         

   568          * @param aConfig Contains context configuration

   569          * @return TInt Success/failure value.

   570          */

   571         TInt SetConfigL( TPacketDataConfigBase* const aConfig );

   572 

   573         /**

   574          * Overloads original ReqCompleted for logging purposes

   575          *

   576          *         

   577          * @param aTsyReqHandle TSY request handle

   578          * @param aError error value

   579          */

   580         virtual void ReqCompleted( const TTsyReqHandle aTsyReqHandle,

   581             const TInt aError );

   582         

   583         /**

   584          * Set/Modify packet filter(s) to secondary context

   585          *

   586          *         

   587          * @param aTsyReqHandle TSY request handle

   588          * @param aPacketFilter Contains packet filter(s) info

   589          * @return TInt Success/failure value.

   590          */

   591         TInt AddPacketFilterL( const TTsyReqHandle aTsyReqHandle,

   592             TDes8* const aPacketFilter );

   593 #ifdef USING_CTSY_DISPATCHER

   594         /**

   595          * Remove packet filter from context

   596          *

   597          *         

   598          * @param aID Contains packet filter ID to be removed

   599          * @return TInt Success/failure value.

   600          */

   601         TInt RemovePacketFilter( TInt* aID );

   602 #else

   603         /**

   604          * Remove packet filter from context

   605          *

   606          *         

   607          * @param aTsyReqHandle TSY request handle

   608          * @param aID Contains packet filter ID to be removed

   609          * @return TInt Success/failure value.

   610          */

   611         TInt RemovePacketFilter( const TTsyReqHandle aTsyReqHandle, TInt* aID );

   612 #endif

   613         /**

   614          * Method invokes MS-initiated modification of an active context in the 

   615          * network

   616          *         

   617          *

   618          * @return TInt Success/failure value.

   619          */

   620         TInt ModifyActiveContextL();

   621 

   622 

   623         /**

   624          * Enumerate context packet filters

   625          *         

   626          *

   627          * @param aTsyReqHandle TSY request handle

   628          * @param aCount Contains packet filter count in return

   629          * @return KErrNone

   630          */

   631         TInt EnumeratePacketFilters( const TTsyReqHandle aTsyReqHandle,

   632             TInt *aCount );

   633 

   634         /**

   635          * Gets filter info specified by index

   636          *         

   637          *

   638          * @param aTsyReqHandle TSY request handle

   639          * @param aIndex of the wanted filter index

   640          * @param aPacketFilterInfo Contains packet filter information

   641          * @return KErrNone

   642          */

   643         TInt GetPacketFilterInfo( const TTsyReqHandle aTsyReqHandle,

   644             TInt* aIndex, TPacketBase* aPacketFilterInfo );

   645 

   646         /**

   647          * Get the DNS info for Etel side request

   648          *         

   649          *

   650          * @param aTsyReqHandle TSY request handle

   651          * @param aDnsInfo Contains DNS information in return

   652          * @return KErrNone.

   653          */

   654         TInt GetDnsInfo( const TTsyReqHandle aTsyReqHandle,

   655             TDes8* const aDnsInfo );

   656 

   657           /**

   658          * Adds authorization params 

   659          *         

   660          *

   661          * @param aTsyReqHandle request handle

   662          * @param aMediaAuthorization params to be added

   663          * @return KErrNone or error code

   664          */     

   665         TInt AddMediaAuthorizationL( const TTsyReqHandle aTsyReqHandle,

   666         	TDes8* aMediaAuthorization );

   667         

   668         /**

   669          * Removes authorization params 

   670          *         

   671          *

   672          * @param aTsyReqHandle request handle

   673          * @param aMediaAuthorization params to be removed

   674          * @return KErrNone

   675          */  

   676         TInt RemoveMediaAuthorization( const TTsyReqHandle aTsyReqHandle,

   677          RPacketContext::TAuthorizationToken* const aAuthorizationToken );

   678             

   679 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   680         /**

   681          * Get current connection information. 

   682          *         

   683          *

   684          * @param aTsyReqHandle request handle

   685          * @param aInfo configuration info object that will be filled by TSY

   686          * @return KErrNone

   687          */  

   688         TInt GetConnectionInfo( const TTsyReqHandle aTsyReqHandle,

   689             TConnectionInfoBase* const aInfo );

   690           

   691         /**

   692          * Notify client when connection information changes.

   693          *         

   694          *

   695          * @param aInfo configuration info object that will be filled by TSY

   696          * @return KErrNone

   697          */              

   698         TInt NotifyConnectionInfoChange( TConnectionInfoBase* const aInfo );            

   699            

   700         /**

   701          * Fill connection info structure. 

   702          *         

   703          *

   704          * @param aInfo configuration info object that will be filled by TSY

   705          * @return KErrNone or KErrNotFound

   706          */              

   707         TInt FillConnectionInfo( TConnectionInfoBase* const aInfo );                              

   708 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   709 

   710 #ifdef REQHANDLE_TIMER

   711 

   712         /**

   713          * Choose the type of response, automatic or common.

   714          * 

   715          *  

   716          * @param aReqHandleType

   717          * @param aTsyReqHandle                         

   718          */

   719         void SetTypeOfResponse( const TInt aReqHandleType, 

   720                 const TTsyReqHandle aTsyReqHandle );

   721 

   722 #endif //REQHANDLE_TIMER

   723 

   724     public: //Data

   725     

   726         // TPacketContextRequestTypes enumerates indexes to Packet's request

   727         // handle table. Request handles are stored there while waiting for 

   728         // completion of the request.

   729         enum TPacketContextRequestTypes

   730             {

   731             EMultimodePacketContextReqHandleUnknown,

   732             EMultimodePacketContextInitialiseContext,

   733             EMultimodePacketContextActivate,

   734             EMultimodePacketContextDeactivate,

   735             EMultimodePacketContextDelete,

   736             EMultimodePacketContextNotifyConfigChanged,

   737             EMultimodePacketContextNotifyConnectionSpeedChange,

   738             EMultimodePacketContextNotifyStatusChange,

   739             EMultimodePacketContextSetConfig,

   740             EMultimodePacketContextGetDataVolumeTransferred,

   741             EMultimodePacketContextGetPacketFilterInfo,

   742             EMultimodePacketContextEnumeratePacketFilters,

   743             EMultimodePacketContextAddPacketFilter,

   744             EMultimodePacketContextRemovePacketFilter,

   745             EMultimodePacketContextModifyActiveContext,

   746             EMultimodePacketContextNotifyConfigChanged99,

   747             EMultimodePacketContextAddMediaAuthorization,

   748 #ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   749             EMultimodePacketContextNotifyConnectionInfoChange,

   750 #endif // SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

   751             // Max number of requests

   752             // ADD NEW REQUESTS BEFORE THIS!

   753             EMaxNumOfPacketContextRequests

   754 

   755             };

   756 

   757     private: // Data

   758 

   759         /**

   760          * Req handle type

   761          */        

   762         TPacketContextRequestTypes iReqHandleType;

   763 

   764         /**

   765          *  Pointer to the Req handle store

   766          *  Own.        

   767          */        

   768         CMmTsyReqHandleStore* iTsyReqHandleStore;

   769         

   770         /**

   771          *  Table for packet context request handles

   772          */        

   773         TTsyReqHandle iPacketContextReqHandles[EMaxNumOfPacketContextRequests];

   774         

   775         /**

   776          *  Pointer to the Packet Service TSY

   777          *  Not own.        

   778          */

   779         CMmPacketServiceTsy* iMmPacketService;                                                

   780         

   781         /**

   782          *  Pointer to the gsm extension

   783          */        

   784         CMmPacketContextGsmWcdmaExt* iMmPacketContextGsmWcdmaExt;                                                

   785 

   786         /**

   787          *  Pointer to the QoS Profile

   788          *  Not own.        

   789          */

   790         CMmPacketQoSTsy* iQoSProfile;                                                

   791 

   792         /**

   793          *  Notify Config Changed

   794          *  Not own.        

   795          */

   796         TPacketDataConfigBase* iRetNotifyConfig;

   797         

   798         /**

   799          *  Notify Config Changed

   800          *  Not own.        

   801          */        

   802         TPacketDataConfigBase* iRetNotifyConfig2;

   803 

   804         /**

   805          *  Notify Connection Speed Change

   806          *  Not own.        

   807          */

   808         TUint* iRetNotifyConnectionSpeed;

   809         

   810         /**

   811          *  Notify Connection Speed

   812          */        

   813         TUint iNotifyConnectionSpeed;

   814 

   815         /**

   816          *  Connection Speed

   817          */

   818         TUint iConnectionSpeed;                                             

   819 

   820         /**

   821          *  Notify Context Status Change

   822          *  Not own.        

   823          */

   824         RPacketContext::TContextStatus* iRetNotifyStatus;                                               

   825 

   826         /**

   827          * Context status   

   828          */

   829         RPacketContext::TContextStatus iContextStatus;

   830 

   831         /**

   832          *  Get Data Volume Transferred

   833          *  Not own.        

   834          */

   835         RPacketContext::TDataVolume* iRetDataVolume;                                                

   836 

   837         /**

   838          *  Data Volume Transferred

   839          */

   840         RPacketContext::TDataVolume iDataVolume;                                                

   841 

   842         /**

   843          *  QoS Profile name

   844          */

   845 

   846         TInfoName iQoSProfileName;                                                

   847 

   848         /**

   849          *  Context name      

   850          */

   851 

   852         TInfoName iContextName;                                                

   853 

   854         /**

   855          * Proxy Id       

   856          */

   857 

   858         TUint8 iProxyId;                                                

   859 

   860         /**

   861          * Context status before suspending       

   862          */

   863 

   864         RPacketContext::TContextStatus iContextStatusBeforeSuspending;        

   865 

   866         /**

   867          *  Last error cause      

   868          */

   869 

   870         TInt iLastErrorCause;       

   871 

   872         /**

   873          *  Is this Dial-Up Context    

   874          */

   875         TBool iIsDialUpContext;

   876 

   877         /**

   878          *  Name of existing context      

   879          */

   880         TInfoName iHostCID;

   881         

   882         /**

   883          *  Connection information received from LTSY.     

   884          */ 

   885         RPacketContext::TConnectionInfoV1 iConnectionInfo;

   886            

   887         /**

   888          *  Pointer to connection info held by client, to be populated when

   889          *  notification request is completed.

   890          *  Not own.        

   891          */            

   892         TConnectionInfoBase* iRetNotifyConnectionInfo;       

   893     };

   894 

   895 #endif // CMMPACKETCONTEXTTSY_H

   896    

   897 // End of File