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 CMMSUPPLSERVTSY_H

    21 #define CMMSUPPLSERVTSY_H

    22 

    23 // INCLUDES

    24 #include <e32base.h>  

    25 #include <etelmm.h>   

    26 #include <et_tsy.h>   

    27 #include <mmretrieve.h> 

    28 #include <centralrepository.h>

    29 

    30 // FORWARD DECLARATIONS

    31 class TDataPackage;

    32 class CMmPhoneTsy;

    33 class CMmTsyReqHandleStore;

    34 class CMmSupplServGsmWcdmaExt;

    35 class CListReadAllAttempt;

    36 class CMmDataPackage;

    37 

    38 // CLASS DECLARATION

    39 /**

    40  *  Supplementary Services-related functionality of Phone Tsy

    41  */

    42 NONSHARABLE_CLASS( CMmSupplServTsy ) : public CBase

    43     {

    44     private: // Enumerations

    45     	struct TMwisInfoRequest

    46     		{

    47     		/** ETel request handle */

    48     		TTsyReqHandle iReqHandle;

    49     		/** pointer to client-side data */

    50     		RMobilePhone::TMobilePhoneMessageWaitingV1* iMwisInfo;

    51     		}; 

    52 

    53     public:  // Constructors and destructor

    54         

    55         /**

    56          * Two-phased constructor.

    57          * @param aPhoneTsy The Phone Tsy object

    58          */

    59         static CMmSupplServTsy* NewL( CMmPhoneTsy* aPhoneTsy );

    60 

    61         /**

    62          * Destructor.

    63          */

    64         virtual ~CMmSupplServTsy();

    65 

    66         // New functions

    67         

    68         /**

    69          * Handles Supplementary Service requests

    70          *          

    71          *

    72          * @param aTsyReqHandle TSY request handle

    73          * @param aIpc request IPC number

    74          * @param aPackage packaged request parameters

    75          * @return result of the request

    76          */

    77         TInt DoExtFuncL( const TTsyReqHandle aTsyReqHandle, 

    78             const TInt aIpc, 

    79             const TDataPackage& aPackage );

    80 

    81         /**

    82          * Cancels Supplementary Service request

    83          *          

    84          *

    85          * @param aIpc request IPC number

    86          * @param aTsyReqHandle TSY request handle

    87          * @return result of the request

    88          */

    89         virtual TInt CancelService( const TInt aIpc, 

    90             const TTsyReqHandle aTsyReqHandle );

    91 

    92         /**

    93          * Calls the needed complete method due timer expiration

    94          *          

    95          *

    96          * @param aReqHandleType req handle type.

    97          * @param aError error value

    98          */

    99         void Complete( TInt aReqHandleType, TInt aError );

   100 

   101         /**

   102          * Notifies client about call service capabilities change

   103          *

   104          * @param aCallServiceCaps The changed call service capabilities

   105          */

   106         void CompleteNotifyCallServiceCapsChange(

   107                 RMobilePhone::TMobilePhoneCallServiceCaps aCallServiceCaps ); 

   108 

   109         /**

   110          * Completes request to retrieve call forwarding status

   111          *          

   112          *

   113          * @param aResults List with results

   114          * @param aErrorCode error/success code

   115          * @return None

   116          */

   117         void CompleteGetCallForwardingStatusPhase1L( 

   118 			     CMobilePhoneCFList* aResults, TInt aErrorCode );

   119 

   120         /**

   121          * Completes call forwarding status setting request

   122          *          

   123          *

   124          * @param aErrorCode error/success code

   125          */

   126         void CompleteSetCallForwardingStatus( TInt aErrorCode );

   127 

   128         /**

   129          * Cancels setting of call forwarding status

   130          *          

   131          *

   132          * @param aTsyReqHandle Request handle

   133          * return KErrNone

   134          */

   135         TInt SetCallForwardingStatusCancel(

   136 			const TTsyReqHandle aTsyReqHandle );

   137 

   138         /**

   139          * Notifies client about forwarding status change

   140          *

   141 		     * @param aCondition The condition which has a changed status

   142          */

   143         void CompleteNotifyCallForwardingStatusChange(

   144 			     RMobilePhone::TMobilePhoneCFCondition aCondition );

   145 

   146         /**

   147          * Completes asynchronous CallForwardingActive notification

   148          *          

   149          *

   150 		     * @param aServiceGroup service group

   151 		     * @param aActiveType type of 

   152 		     * forwarding (conditional/unconditional)e

   153          */

   154         void CompleteNotifyCallForwardingActive(

   155 			     RMobilePhone::TMobileService aServiceGroup,

   156 			     RMobilePhone::TMobilePhoneCFActive aActiveType );

   157 

   158         // Call Barring

   159 

   160         /**

   161          * Completes fetching of call barring status

   162          *          

   163          *

   164          * @param aResults List with results

   165          * @param aErrorCode error/success code

   166          */

   167         void CompleteGetCallBarringStatusPhase1L(

   168 			     CMobilePhoneCBList* aResults, TInt aErrorCode );

   169 

   170         /**

   171          * Completes barring status setting

   172          *          

   173          *

   174          * @param aErrorCode error/success code

   175          */

   176         void CompleteSetCallBarringStatus( TInt aErrorCode );

   177 

   178         /**

   179          * Notifies client about barring status change

   180          *          

   181          *

   182 		     * @param aCondition The condition which has a changed status

   183          * @return None

   184          */

   185         void CompleteNotifyCallBarringStatusChange(

   186 			RMobilePhone::TMobilePhoneCBCondition aCondition );

   187 

   188 

   189 		    /**

   190          * Completes SetSSPassword request.

   191          *          

   192          *

   193          * @param aErrorCode Error value

   194          */

   195         void CompleteSetSSPassword( TInt aErrorCode );

   196 

   197 

   198         /**

   199          * Complete GetCallWaitingStatusPhase1

   200          *          

   201          *

   202          * @param aResults List with results

   203          * @param aErrorCode Error code

   204          */

   205         void CompleteGetCallWaitingStatusPhase1L( 

   206 			     CMobilePhoneCWList* aResults, TInt aErrorCode );

   207         

   208         /**

   209          * Completes setting of call waiting status

   210          *          

   211          *

   212          * @param aErrorCode error/success code

   213          */

   214         void CompleteSetCallWaitingStatus( TInt aErrorCode );

   215         

   216         /**

   217          * Notifies client about change of call waiting status if ordered

   218          *          

   219          *

   220          * @param aChangedCwStatus The changed service group and status

   221          */

   222         void CompleteNotifyCallWaitingStatusChange(

   223 		        RMobilePhone::TMobilePhoneCWInfoEntryV1 const* aChangedCwStatus );

   224 

   225         /**

   226          * completes the GetIdentityServiceStatus method

   227          *          

   228          *

   229          * @param aStatus the returned status

   230          * @param aErrorCode:error/success code

   231          */

   232         void CompleteGetIdentityServiceStatus( 

   233 			     RMobilePhone::TMobilePhoneIdServiceStatus aStatus, 

   234 			     TInt aErrorCode );

   235 

   236         /**

   237          * Completes network service request

   238          *          

   239          *

   240          * @param aErrorCode error/success code 

   241          */

   242         virtual void CompleteSendNetworkServiceRequest( TInt aErrorCode );

   243 

   244         /** 

   245          * Completes network service request with no FDN check

   246          *          

   247          *

   248          * @param aErrorCode error/success code 

   249          */

   250         virtual void CompleteSendNetworkServiceRequestNoFdnCheck( TInt aErrorCode );

   251         

   252         /**

   253          * Completes the GetIccMessageWaitingIndicator request.  

   254          *          

   255          *

   256          * @param aMessageWaiting ICC message waiting indicators

   257          * @param aErrorCode Error value

   258          */

   259         void CompleteGetIccMessageWaitingIndicators( 

   260             RMobilePhone::TMobilePhoneMessageWaitingV1* aMessageWaiting, 

   261             TInt aErrorCode );

   262         

   263         /**

   264          * Cancels an outstanding GetIccMessageWaitingIndicators request  

   265          *          

   266          *

   267          * @param aTsyReqHandle TSY request handle,complete with KErrCancel

   268          * @return result of the request

   269          */

   270         TInt GetIccMessageWaitingIndicatorsCancel( 

   271             const TTsyReqHandle aTsyReqHandle );

   272 

   273         /**

   274          * Completes the SetIccMessageWaitingIndicator request.  

   275          *          

   276          *

   277          * @param aErrorCode Error value

   278          */

   279         void CompleteSetIccMessageWaitingIndicators( TInt aErrorCode );

   280         

   281         /**

   282          * Cancels an outstanding SetIccMessageWaitingIndicators request 

   283          *          

   284          *

   285          * @param aTsyReqHandle TSY request handle, complete with KErrCancel

   286          * @return KErrNone

   287          */

   288         TInt SetIccMessageWaitingIndicatorsCancel( 

   289             const TTsyReqHandle aTsyReqHandle );

   290 

   291         /**

   292          * Completes the IccMessageWaitingIndicatorChange-notificatio if

   293          * the indicator values has changed. 

   294          *          

   295          *

   296          * @param aMessageWaiting ICC message waiting indicators

   297          * @param aErrorCode Error value

   298          */

   299         void CompleteNotifyIccMessageWaitingIndicatorChange(

   300             RMobilePhone::TMobilePhoneMessageWaitingV1* aMessageWaiting,

   301             TInt& aErrorCode );   

   302         

   303         /**

   304          * Cancels an outstanding NotifyIccMessageWaitingIndicatorChange 

   305          * request 

   306          *          

   307          *

   308          * @param aTsyReqHandle TSY request handle, complete with KErrCancel

   309          * @return KErrNone

   310          */

   311         TInt NotifyIccMessageWaitingIndicatorChangeCancel( 

   312             const TTsyReqHandle aTsyReqHandle );

   313         

   314         /**

   315          * Set ICC support for message waiting indicators. 

   316          * request 

   317          *          

   318          *

   319          * @param aSupport ETrue if ICC supports

   320          */

   321         void SetIccSupportForMWIS( TBool aSupport ); 

   322 

   323         /**

   324          * Complete notification for send network requests

   325          *          

   326          *

   327          * @param aErrorCode Error code

   328          * @param aDataPackage data package

   329          */

   330         void CompleteSendNetworkServiceRequestInd( TInt aError,

   331         	CMmDataPackage* aDataPackage  );

   332         

   333         /**

   334          * Complete notification for all send network requests

   335          *          

   336          *

   337          * @param aErrorCode Error code

   338          * @param aDataPackage data package

   339          */

   340         void CompleteNotifyAllSendNetworkServiceRequest( TInt aError, 

   341             CMmDataPackage* aDataPackage  );

   342         

   343         /**

   344          * Change the bootup flag of ICC MWIS.

   345          * PhoneTSY will need to change the bootupflag after CentRep reset.

   346          *

   347          * @param aBootUp Bootup flag: (ETrue if initial data)

   348          */

   349         void SetIccMwisBootUpFlag( TBool aBootUp );

   350         

   351     private:

   352 

   353         /**

   354          * C++ default constructor.

   355          */

   356         CMmSupplServTsy();

   357 

   358         /**

   359          * By default Symbian 2nd phase constructor is private.

   360          */

   361         void ConstructL();

   362 

   363         /**

   364          * This method returns the combination of the static and dynamic call 

   365          * service capabilities of the phone.

   366          *           

   367          *

   368          * @param aTsyReqHandle Tsy request handle

   369          * @param aCaps current capabilities

   370          * @return KErrNone

   371          */

   372         TInt GetCallServiceCaps( const TTsyReqHandle aTsyReqHandle, 

   373             TUint32* aCaps );

   374 

   375         /**

   376          * This request allows a client to be notified when the phone's call 

   377          * service capabilities change

   378          *           

   379          *

   380          * @param aCaps new capabilities

   381          * @return KErrNone

   382          */

   383         TInt NotifyCallServiceCapsChange( TUint32* aCaps );

   384 

   385         /**

   386          * Cancels order to notify if phone's call service capabilities change

   387          *          

   388          *

   389          * @param aTsyReqHandle Tsy request handle

   390          * @return KErrNone

   391          */

   392         TInt NotifyCallServiceCapsChangeCancel( 

   393             const TTsyReqHandle aTsyReqHandle );

   394 

   395         /**

   396          * First phase of fetching call forwarding status.

   397          *          

   398          *

   399          * @param aTsyReqHandle: request handle

   400          * @param aReqData request data

   401          * @param aBufSize buffer size

   402          * @return KErrNone

   403          */

   404         TInt GetCallForwardingStatusPhase1L( 

   405             const TTsyReqHandle aTsyReqHandle, 

   406             CRetrieveMobilePhoneCFList::TGetCallForwardingRequest* aReqData, 

   407             TInt* aBufSize );

   408 

   409         /**

   410          * Second phase of fetching call forwarding status

   411          *          

   412          *

   413          * @param aTsyReqHandle request handle

   414          * @param aClient client id

   415          * @param aBuf buffer for status storing

   416          * @return KErrNone

   417          */

   418         TInt GetCallForwardingStatusPhase2( const TTsyReqHandle aTsyReqHandle, 

   419             RMobilePhone::TClientId const* aClient, 

   420             TDes8* aBuf );

   421 

   422         /**

   423          * Cancels order to retrieve call forwarding status

   424          *          

   425          *

   426          * @param aTsyReqHandle request handle

   427          * @return KErrNone

   428          */

   429         TInt GetCallForwardingStatusCancel( 

   430             const TTsyReqHandle aTsyReqHandle );

   431 

   432         /**

   433          * This method sets a new status and/or registered information for 

   434          * the call forwarding condition specified by the aCondition parameter

   435          *          

   436          *

   437          * @param aTsyReqHandle request handle

   438          * @param aCondition forwarding  condition

   439          * @param aInfo the status and information change to be applied  

   440          * @return KErrNone

   441          */

   442         TInt SetCallForwardingStatusL( const TTsyReqHandle aTsyReqHandle, 

   443             RMobilePhone::TMobilePhoneCFCondition* aCondition, 

   444             const RMobilePhone::TMobilePhoneCFChangeV1* aInfo );

   445 

   446         /**

   447          * This request allows a client to be notified when the status or 

   448          * associated information changes for any of the call forwarding 

   449          * conditions as applied to any of the basic service groups

   450          *          

   451          *

   452          * @param aCondition forwarding condition

   453          * @return KErrNone

   454          */

   455         TInt NotifyCallForwardingStatusChange( 

   456             RMobilePhone::TMobilePhoneCFCondition* aCondition );

   457 

   458         /**

   459          * This notification triggers whenever a call is made on a particular 

   460          * line and a call forwarding service is active on this line at the 

   461          * time

   462          *          

   463          *

   464          * @param aServiceGroup Active basic service groups

   465          * @param aActiveType Active type of CF services

   466          * @return KErrNone

   467          */

   468         TInt NotifyCallForwardingActive( 

   469             RMobilePhone::TMobileService* aServiceGroup,

   470             RMobilePhone::TMobilePhoneCFActive* aActiveType );

   471 

   472         /**

   473          * Cancels order to notify if a call is made on particular line and 

   474          * a call forwarding service is active on this line at the time

   475          *          

   476          *

   477          * @param aTsyReqHandle Tsy request handle

   478          * @return KErrNone

   479          */

   480         TInt NotifyCallForwardingActiveCancel( 

   481             const TTsyReqHandle aTsyReqHandle );

   482 

   483         /**

   484          * Cancels order to notify if call forwarding status changes

   485          *          

   486          *

   487          * @param aTsyReqHandle Tsy request handle

   488          * @return KErrNone

   489          */

   490         TInt NotifyCallForwardingStatusChangeCancel( 

   491             const TTsyReqHandle aTsyReqHandle );

   492 

   493         /**

   494          * First phase of fetching call barring status

   495          *          

   496          *

   497          * @param aTsyReqHandle request handle

   498          * @param aReqData request data

   499          * @param aBufSize size of buffer where status will be stored

   500          * @return KErrNone

   501          */

   502         TInt GetCallBarringStatusPhase1L( const TTsyReqHandle aTsyReqHandle, 

   503             CRetrieveMobilePhoneCBList::TGetCallBarringRequest* aReqData, 

   504             TInt* aBufSize );

   505 

   506         /**

   507          * Second phase of fetching call barring status

   508          *          

   509          *

   510          * @param aTsyReqHandle request handle

   511          * @param aClient client identity

   512          * @param aBuf buffer where data will be stored

   513          * @return KErrNone

   514          */

   515         TInt GetCallBarringStatusPhase2( const TTsyReqHandle aTsyReqHandle, 

   516             RMobilePhone::TClientId const* aClient, 

   517             TDes8* aBuf );

   518 

   519         /**

   520          * Cancels fetching of call barring status

   521          *          

   522          *

   523          * @param aTsyReqHandle request handle

   524          * @return KErrNone

   525          */

   526         TInt GetCallBarringStatusCancel( 

   527             const TTsyReqHandle aTsyReqHandle );

   528 

   529         /**

   530          * This method sets the call barring status for the call barring 

   531          * condition specified by the aCondition parameter

   532          *          

   533          *

   534          * @param aTsyReqHandle request handle

   535          * @param aCondition barring condition

   536          * @param aInfo barring information

   537          * @return KErrNone

   538          */

   539         TInt SetCallBarringStatusL( const TTsyReqHandle aTsyReqHandle, 

   540             RMobilePhone::TMobilePhoneCBCondition* aCondition,

   541             const RMobilePhone::TMobilePhoneCBChangeV1* aInfo );

   542 

   543         /**

   544          * Cancels setting of call barring status

   545          *          

   546          *

   547          * @param aTsyReqHandle Request handle

   548          * return KErrNone

   549          */

   550         TInt SetCallBarringStatusCancel( const TTsyReqHandle aTsyReqHandle );

   551 

   552         /**

   553          * This request allows a client to be notified when the status or 

   554          * associated information changes for any of the call barring conditions

   555          * as applied to any of the basic service groups

   556          *          

   557          *

   558          * @param aCondition Parameter where possible new data will be stored

   559          * @return KErrNone

   560          */

   561         TInt NotifyCallBarringStatusChange(

   562             RMobilePhone::TMobilePhoneCBCondition* aCondition );

   563 

   564         /**

   565          * Cancels order to notify if barring status changes

   566          *          

   567          *

   568          * @param aTsyReqHandle request handle

   569          * @return KErrNone

   570          */

   571         TInt NotifyCallBarringStatusChangeCancel( 

   572             const TTsyReqHandle aTsyReqHandle );

   573 

   574         /**

   575          * Set SS password. Leaves checking of password to network

   576          *          

   577          *

   578          * @param aTsyReqHandle TSY request handle

   579          * @param aPasswordPckg; Password package

   580          * @param aSsService SS service for password change

   581          * @return KErrNone

   582          */

   583         TInt SetSSPasswordL( const TTsyReqHandle aTsyReqHandle,

   584             TDes8* aPasswordPckg, TInt const* aSsService );

   585 

   586         /**

   587          * Cancels setting of SS password

   588          *          

   589          *

   590          * @param aTsyReqHandle Request handle

   591          * @return KErrNone

   592          */

   593         TInt SetSSPasswordCancel( const TTsyReqHandle aTsyReqHandle );

   594 

   595         /**

   596          * First phase of fetching call waiting status

   597          *          

   598          *

   599          * @param aTsyReqHandle request handle

   600          * @param aReqData request data

   601          * @param aBufSize Size of buffer where data will be stored

   602          * @return KErrNone

   603          */

   604         TInt GetCallWaitingStatusPhase1L( const TTsyReqHandle aTsyReqHandle, 

   605             CRetrieveMobilePhoneCWList::TGetCallWaitingRequest const* aReqData, 

   606             TInt* aBufSize );

   607 

   608         /**

   609          * Second phase of fetching call waiting status

   610          *          

   611          *

   612          * @param aTsyReqHandle request handle

   613          * @param aClient client identity

   614          * @param aBuf buffer where data will be stored

   615          * @return KErrNone

   616          */

   617         TInt GetCallWaitingStatusPhase2( const TTsyReqHandle aTsyReqHandle, 

   618             RMobilePhone::TClientId const* aClient, 

   619             TDes8* aBuf );

   620 

   621         /**

   622          * Cancels fetching of call waiting status

   623          *          

   624          *

   625          * @param aTsyReqHandle request handle

   626          * @return KErrNone

   627          */

   628         TInt GetCallWaitingStatusCancel( const TTsyReqHandle aTsyReqHandle );

   629 

   630         /**

   631          * This method sets the call waiting status

   632          *          

   633          *

   634          * @param aTsyReqHandle request handle

   635          * @param aServiceGroup service group where new status will be applied

   636          * @param aAction action to take

   637          * @return KErrNone

   638          */

   639         TInt SetCallWaitingStatusL( const TTsyReqHandle aTsyReqHandle,

   640             RMobilePhone::TMobileService* aServiceGroup, 

   641             RMobilePhone::TMobilePhoneServiceAction* aAction );

   642 

   643         /**

   644          * Cancels setting of call waiting status

   645          *          

   646          *

   647          * @param aTsyReqHandle Request handle

   648          * @return KErrNone

   649          */

   650         TInt SetCallWaitingStatusCancel( const TTsyReqHandle aTsyReqHandle );

   651 

   652         /**

   653          * This request allows a client to be notified when the status changes 

   654          * for the call waiting service as applied to any of the basic service 

   655          * groups

   656          *          

   657          *

   658          * @param aCWStatus parameter where possible new status will be stored

   659          * @return KErrNone or KErrArgument

   660          */

   661         TInt NotifyCallWaitingStatusChange( TDes8* aCWStatus );

   662 

   663         /**

   664          * Cancels order to notify if call waiting status changes

   665          *          

   666          *

   667          * @param aTsyReqHandle request handle

   668          * @return KErrNone

   669          */

   670         TInt NotifyCallWaitingStatusChangeCancel( 

   671             const TTsyReqHandle aTsyReqHandle );

   672 

   673         /**

   674          * This method retrieves the current status of the identity service 

   675          *          

   676          *

   677          * @param aTsyReqHandle request handle

   678          * @param aServiceAndLocation location whence information will be 

   679          * retrieved and service to specify the group of requested status

   680          * @param aStatus variable where information will be gathered

   681          * @return KErrNone

   682          */

   683         TInt GetIdentityServiceStatusL( const TTsyReqHandle aTsyReqHandle, 

   684             RMobilePhone::TIdServiceAndLocation* aServiceAndLocation,

   685             RMobilePhone::TMobilePhoneIdServiceStatus* aStatus );

   686 

   687         /**

   688          * Cancels the request to retrieve identity service status

   689          *          

   690          *

   691          * @param aTsyReqHandle request handle

   692          * @return KErrNone

   693          */

   694         TInt GetIdentityServiceStatusCancel( 

   695             const TTsyReqHandle aTsyReqHandle );

   696 

   697         /**

   698          * This method sends a network service request string 

   699          *          

   700          *

   701          * @param aTsyReqHandle request handle

   702          * @param aServiceString request string

   703          * @return KErrNone

   704          */

   705         TInt SendNetworkServiceRequestL( const TTsyReqHandle aTsyReqHandle, 

   706             const TDesC* aServiceString );

   707            

   708         /**

   709          * Retrieves the set of message waiting indicators 

   710          * from the current ICC.

   711          *          

   712          *

   713          * @param aTsyReqHandle Request handle

   714          * @param aMessageWaiting ICC message waiting indicators

   715          * @return Error value

   716          */

   717         TInt GetIccMessageWaitingIndicatorsL( 

   718             const TTsyReqHandle aTsyReqHandle, 

   719             RMobilePhone::TMobilePhoneMessageWaitingV1* aMessageWaiting );

   720         

   721         /**

   722          * Sets the message waiting indicators on the current ICC.

   723          *          

   724          *

   725          * @param aTsyReqHandle Request handle

   726          * @param aParams ICC message waiting indicators

   727          * @return Error value

   728          */

   729         TInt SetIccMessageWaitingIndicatorsL( 

   730             const TTsyReqHandle aTsyReqHandle, 

   731             TDes8* aParams );        

   732 

   733         /**

   734          * Notifies if the message waiting indicators on the 

   735          * current ICC has been changed. 

   736          *          

   737          *

   738          * @param aMessageWaiting ICC message waiting indicators

   739          * @return KErrNone

   740          */

   741         TInt NotifyIccMessageWaitingIndicatorsChange( 

   742             RMobilePhone::TMobilePhoneMessageWaitingV1*  aMessageWaiting );

   743             

   744         /**

   745          * Read Icc Message Waiting indicators from the Central Repository.

   746          *          

   747          *

   748          * @param aMessageWaiting ICC message waiting indicators

   749          * @return Error value

   750          */

   751         TInt ReadIccMessageWaitingIndicatorsFromCentRep( 

   752             RMobilePhone::TMobilePhoneMessageWaitingV1& aMessageWaiting );

   753             

   754         /**

   755          * Write Icc Message Waiting indicators to the Central Repository.

   756          *          

   757          *

   758          * @param aMessageWaiting ICC message waiting indicators

   759          * @return Error value

   760          */

   761         TInt WriteIccMessageWaitingIndicatorsToCentRep( const 

   762             RMobilePhone::TMobilePhoneMessageWaitingV1& aMessageWaiting );

   763         

   764         /**

   765          * Is the Message Waiting indicator -information changed. 

   766          *          

   767          *

   768          * @param aMessageWaiting ICC message waiting indicators

   769          * @return Etrue if the information is unequal

   770          */

   771         TBool IsMwisInfoChanged( const 

   772             RMobilePhone::TMobilePhoneMessageWaitingV1& aNewMessageWaiting );            

   773 

   774         /**

   775          * Notification for send network request

   776          * 

   777          * @param aOperation Supplies the SS operation to be notified about 

   778          * @param aRequestComplete operation code and any additional information parameters 

   779          * @return Error value

   780          */

   781         TInt NotifySendNetworkServiceRequest(

   782             const RMobilePhone::TMobilePhoneNotifySendSSOperation* aOperation,

   783             TDes8* aRequestComplete );

   784 

   785         /**

   786          * Cancel notification for send network request         

   787          *

   788          * @param aTsyReqHandle TSY request handle

   789          * @return KErrCancel

   790          */    

   791         TInt NotifySendNetworkServiceRequestCancel(

   792             const TTsyReqHandle aTsyReqHandle );

   793         

   794         /**

   795          * Notification for all send network request

   796          *           

   797          *

   798          * @param aOperation On return, will contain the type of operation i.e. Send SS request invokation, return result/error or reject.

   799          * @param aRequestComplete operation code and any additional information parameters 

   800          * @return Error value

   801          */

   802         TInt NotifyAllSendNetworkServiceRequest( 

   803             RMobilePhone::TMobilePhoneNotifySendSSOperation* aOperation,

   804             TDes8* aRequestComplete );

   805 

   806         /**

   807          * Cancel notification for all send network request

   808          *          

   809          *

   810          * @param aTsyReqHandle TSY request handle

   811          * @return KErrCancel

   812          */    

   813         TInt NotifyAllSendNetworkServiceRequestCancel(

   814             const TTsyReqHandle aTsyReqHandle );            

   815 

   816 	private: // member data

   817 

   818        /** 

   819         * Pointer to phone Tsy

   820         */		     

   821         CMmPhoneTsy* iMmPhone;

   822 

   823        /** 

   824         * Call service capabilities

   825         */		     

   826         TUint32 iCallServiceCaps;

   827 

   828         /**

   829          * Pointer to client side for SS capabilities

   830          */         

   831         TUint32* iRetCallServiceCaps;

   832 

   833         /**

   834          * Flow control is removed and 

   835          * iSsTransactionOngoing flag is used instead.

   836          */         

   837         TBool iSsTransactionOngoing;

   838 

   839         /**

   840          * Get call forwarding status size buffer (phase 1)

   841          */         

   842         TInt* iRetCFStatusSize;

   843 

   844         /**

   845          * Call forwarding condition

   846          */         

   847         RMobilePhone::TMobilePhoneCFCondition* iRetCallForwardingCondition;

   848 

   849         /**

   850          * Pointer to client side for call forwarding service group changes

   851          */         

   852         RMobilePhone::TMobileService* iRetServiceGroup;

   853         

   854         /**

   855          * Pointer to client side for call forwarding active type changes

   856          */         

   857         RMobilePhone::TMobilePhoneCFActive* iRetActiveType;

   858 

   859         /**

   860          * Call forwarding list, in streamed format, for two phased retrieval

   861          */		     

   862         CBufBase* iCFList;

   863 

   864         /**

   865          * Call forwarding client id for two phased list retrieval

   866          */		     

   867 		    RMobilePhone::TClientId* iCFClientId;

   868 		    

   869         /**

   870          * Get call barring status size buffer (phase 1)

   871          */         

   872         TInt* iRetCBStatusSize;

   873 

   874         /**

   875          * Call barring condition

   876          */         

   877         RMobilePhone::TMobilePhoneCBCondition* iRetCallBarringCondition;

   878 

   879         /**

   880          * Call barring list, in streamed format, for two phased retrieval

   881          */		     

   882         CBufBase* iCBList;

   883 

   884         /**

   885          * Call barring client id for two phased list retrieval

   886          */		     

   887         RMobilePhone::TClientId* iCBClientId;

   888 		    

   889         /** 

   890          * Get call waiting status size buffer (phase 1)

   891          */         

   892         TInt* iRetCWStatusSize;

   893 

   894         /**

   895          * Call waiting list, in streamed format, for two phased retrieval

   896          */		     

   897         CBufBase* iCWList;

   898 

   899         /**

   900          * Call waiting client id for two phased list retrieval

   901          */		     

   902         RMobilePhone::TClientId* iCWClientId;

   903 

   904         /**

   905          * Pointer to client side for call waiting status changes

   906          */         

   907         TDesC8* iRetNotifyCallWaitingStatus;

   908 

   909         /**

   910          * Pointer to client side for identity service status

   911          */         

   912         RMobilePhone::TMobilePhoneIdServiceStatus* iRetGetIdentityServiceStatus;

   913         

   914         /**

   915          * Pointer to client side for CFCondition

   916          */ 

   917         RMobilePhone::TMobilePhoneCFCondition* iCondition;

   918     	

   919         /**

   920          * Pointer to client side for CFChangeV1

   921          */ 

   922     	const RMobilePhone::TMobilePhoneCFChangeV1* iInfo;

   923     	

   924        /**

   925         * Pointer to Mwis Central Repository

   926         * Not Own.

   927         */

   928         CRepository* iMwisCentRep;

   929        

   930        /**

   931         * Pointer to Cfis Central Repository

   932         */

   933         CRepository* iCfisCentRep;

   934         

   935        /**

   936         * Pointer to Cfis Private Central Repository

   937         */

   938         CRepository* iCFISPrivateCentRep;

   939              

   940         /**

   941          * Up-to-date information of Message Waiting Indicators.

   942          */

   943         RMobilePhone::TMobilePhoneMessageWaitingV1 iMessageWaiting; 

   944         

   945         /**

   946          * Pointer to clients Message Waiting Indicators, Set-method.

   947          * Not Own.

   948          */

   949         RMobilePhone::TMobilePhoneMessageWaitingV1* 

   950             iRetSetMessageWaiting;

   951        

   952         /**

   953          * Pointer to clients Message Waiting Indicators, Notify-method. 

   954          * Not Own.

   955          */

   956         RMobilePhone::TMobilePhoneMessageWaitingV1* 

   957             iRetNotifyMessageWaiting;

   958         

   959         /**

   960          * Get Icc support during the boot up.

   961          */

   962         TBool iGetIccSupportAtBoot;

   963         

   964         /**

   965          * Mwis is supported by ICC.

   966          */

   967         TBool iMessageWaitingSupportedByIcc;

   968         

   969         /** 

   970          * Indicating status of NoFdnCheck

   971          */ 

   972         enum TSsNoFdnCheckStatus

   973             {

   974             ESsNoFdnCheckUnknown, 

   975             ESsNoFdnCheckUsed,

   976             ESsNoFdnCheckNotUsed                      

   977             }; 

   978  

   979         /**

   980          * Indicating NoFdnCheck request usage

   981          */

   982         TSsNoFdnCheckStatus iSsNoFdnCheckFlag;

   983 

   984         /**

   985          * Pointer to client's network service event data, to be populated on receiving notification of an event 

   986          */  

   987         RMobilePhone::TMobilePhoneSendSSRequestV3* iRetSSDataPtrIndRequest;

   988         

   989         /**

   990          * Holds the SS operation the client wants to be notified about 

   991          */

   992         RMobilePhone::TMobilePhoneNotifySendSSOperation iInputSSOperation;

   993         

   994         /**

   995          * Pointer to client side SS operation

   996          */        

   997         RMobilePhone::TMobilePhoneNotifySendSSOperation* iRetSSOperationPtr;

   998        

   999         /**

  1000          * Pointer to client side data

  1001          */  

  1002         RMobilePhone::TMobilePhoneSendSSRequestV3* iRetSSDataPtrAllRequest;

  1003 

  1004         /**

  1005          * Array for buffering MWIS information requests

  1006          */

  1007         RPointerArray< TMwisInfoRequest > iMwisInfoRequests;

  1008 

  1009     };

  1010 

  1011 #endif  // CMMSUPPLSERVTSY_H            

  1012 

  1013 // End of File