1 /*

     2 * Copyright (c) 2002-2007 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:  This file contains the header file of the CPEParserSSHandler

    15 *                object

    16 *

    17 */

    18 

    19 

    20 

    21 #ifndef CPEPARSERSSHANDLER_H

    22 #define CPEPARSERSSHANDLER_H

    23 

    24 //  INCLUDES

    25 #include <CPhoneGsmSsHandler.h>

    26 #include <pevirtualengine.h>

    27 #include <nwdefs.h>

    28 #include <MPsetRequestObs.h>

    29 

    30 // FORWARD DECLARATIONS

    31 class CPEMessageHandler;

    32 class CPsetContainer;

    33 class CPsetCallWaiting;

    34 class CPsetCallBarring;

    35 class CPsetCallDiverting;

    36 class CPsetCli;

    37 class CPsuiContainer;

    38 class CPsuiWaitingObs;

    39 class CPsuiBarringObs;

    40 class CPsuiDivertObs;

    41 class CPsuiCliObserver;

    42 

    43 // CLASS DECLARATION

    44 

    45 /**

    46 *  Handles phone related messages from the MPEPhoneModelInternal object.

    47 *

    48 *  @lib phoneenginegsm

    49 *  @since Series60 4.0

    50 */

    51 NONSHARABLE_CLASS( CPEParserSSHandler ) : public CPhoneGsmSsHandler, 

    52                               public MPsetRequestObserver

    53     {

    54     public:  // Constructors and destructor

    55         

    56         /**

    57         * Two-phased constructor.

    58         */

    59         static CPEParserSSHandler* NewL

    60             (

    61             CPEMessageHandler& aOwner,   

    62             MPEPhoneModelInternal& aModel 

    63             );

    64 

    65         /**

    66         * Destructor.

    67         */

    68         virtual ~CPEParserSSHandler();

    69 

    70      public: // New functions

    71 

    72         /**

    73         * Returns RMobilePhone::TMobileService type of basic service code.

    74         *

    75         * @param aBasicCode It is basic service code.

    76         * @return basic service code.

    77         */

    78         RMobilePhone::TMobileService BasicService( const TDesC& aBasicCode ); 

    79 

    80         /**

    81         * changes parameter to basic service code

    82         */

    83         TBasicServiceGroups ChangeToBsc( const TDesC& aBasicCode );

    84 

    85     public: // Functions from base classes

    86 

    87         /**

    88         * Cancel SS string command. Method cancel command from Settings utility

    89         * subsytem or security module.

    90         *

    91         * @return possible error code

    92         */

    93         TInt Cancel();

    94 

    95         /**

    96         * Process barring procedures(derived from CPESsHandler).

    97         *

    98         * See comments for forwarding, they apply also in here.

    99         *

   100         * @param aAction It is action.

   101         * @param aBarring It contains barring procedure.

   102         * @param aPassword It should be barring password, if required.

   103         * @param aBasicCode It is basic service code.

   104         */

   105         void ProcessBarringL( TAction aAction, 

   106                               TBarringProcedure aBarring, 

   107                               const TDesC& aPassword, 

   108                               const TDesC& aBasicCode );

   109 

   110         /**

   111         * Process calling line identification presentation status

   112         * (derived from CPEGsmSsHandler).

   113         */

   114         void ProcessClipStatusL();

   115 

   116         /**

   117         * Process calling line idnetification restriction status

   118         * (derived from CPEGsmSsHandler).

   119         */

   120         void ProcessClirStatusL();

   121 

   122         /**

   123         * Process Calling Name Presentation (CNAP) status check.

   124         */

   125         void ProcessCnapStatusL();

   126 

   127         /**

   128         * Process connected line presentation status(derived from CPEGsmSsHandler).

   129         */

   130         void ProcessColpStatusL();

   131 

   132         /**

   133         * Process connected line restriction status(derived from CPEGsmSsHandler).

   134         */

   135         void ProcessColrStatusL();

   136 

   137         /**

   138         * Process enhanced Multi-Level Precedence and Pre-emption (eMLPP).

   139         *

   140         * @param aAction It is action.

   141         * @param aNumber It is directory number.

   142         * @param aServiceCode It is service code.

   143         */

   144         void ProcessEmlppL( TAction aAction, 

   145                             const TDesC& /*aNumber*/,

   146                             const TInt aServiceCode );

   147 

   148         /**

   149         * Process forwarding procedures(derived from CPEGsmSsHandler).

   150         *

   151         * If a parameter is not allowed for a procedure,

   152         * then it is empty. If a parameter is not explicitly given,

   153         * then it is empty. If a parameter is present, then it can

   154         * be assumed to contain appropriate values.

   155         *

   156         * @param aAction It is action.

   157         * @param aForwarding It contains forwarding procedure.

   158         * @param aNumber It is directory number.

   159         * @param aBasicCode It is basic service code.

   160         * @param aTimer It is timer(delay time).

   161         */

   162         void ProcessForwardingL( TAction aAction, 

   163                                  TForwardingProcedure aForwarding, 

   164                                  const TDesC& aNumber, 

   165                                  const TDesC& aBasicCode, 

   166                                  const TDesC& aTimer );

   167         

   168         /**

   169         * Process Multiple Subscriber Profile (MSP).

   170         *

   171         * @param aAction It is action.

   172         * @param aNumber It is directory number.

   173         * @param aServiceCode It is service code.

   174         */

   175         void ProcessMspL( TAction aAction, 

   176                           const TDesC& aNumber, 

   177                           const TInt aServiceCode );

   178 

   179         /**

   180         * Process password change(derived from CPEGsmSsHandler).

   181         *

   182         * @param aPassword It is password procedure.

   183         * @param aOldPassword It should be old password.

   184         * @param aNewPassword1 It is new password.

   185         * @param aNewPassword2 It is new password.

   186         */

   187         void ProcessPasswordChangeL( TPasswordProcedure aPassword, 

   188                                     const TDesC& aOldPassword, 

   189                                     const TDesC& aNewPassword1, 

   190                                     const TDesC& aNewPassword2 );

   191 

   192         /**

   193         * Process Support for Private Numbering Plan (SPNP).

   194         *

   195         * @param aAction It is action.

   196         * @param aServiceCode It is service code.

   197         */

   198         void ProcessSpnpL( TAction aAction, const TInt aServiceCode );

   199 

   200         /**

   201         * Process waiting(derived from CPEGsmSsHandler).

   202         *

   203         * @param aAction It is action.

   204         * @param aBasicCode It is basic service code.

   205         */

   206         void ProcessWaitingL( TAction aAction, const TDesC& aBasicCode );   

   207 

   208         /**

   209         * From MPsetRequestObs, called when request is completed  

   210         * so that also ui browsing is ended

   211         */

   212         void RequestComplete();

   213             

   214         /**

   215         * From MPsetRequestObs, called when request state changes  

   216         * @param aNewStatus Request status, when request finishes

   217         */

   218         void RequestStatusChanged( TInt aNewStatus );

   219 

   220     private: 

   221 

   222         /**

   223         * C++ default constructor.

   224         */

   225         CPEParserSSHandler( CPEMessageHandler& aOwner,  

   226                                 MPEPhoneModelInternal& aModel); 

   227         

   228         /**

   229         * Connects class to the phonesettings

   230         */

   231         void ConnectToSsEngineL();

   232 

   233         /**

   234         * Create call barring observer

   235         */

   236         void CPEParserSSHandler::CreateCBObsL();

   237     

   238         /**

   239         * Create call cli observer

   240         */

   241         void CPEParserSSHandler::CreateCliObsL();          

   242         

   243         /**

   244         * Create call divert observer

   245         */

   246         void CPEParserSSHandler::CreateCFObsL();

   247 

   248         /**

   249         * Create call waiting observer

   250         */

   251         void CPEParserSSHandler::CreateCWObsL();

   252 

   253         /**

   254         * if ConnectSsToEngine leaves, this is called

   255         */

   256         static void DoClean( TAny* aAny );

   257         

   258         /**

   259         * deletes member variables

   260         */

   261         void ResetVariables();

   262 

   263         /**

   264         * Copies destructor. If does not fit, then leaves with

   265         * KErrOverflow error code.

   266         */

   267         static void CopyL( TDes& aDest, const TDesC& aSource );

   268 

   269     private:

   270         // CPEGsmMessageHandler object which owns this requester.

   271         CPEMessageHandler& iOwner;

   272         //MPEPhoneModelInternal is used to send message to the phone application

   273         MPEPhoneModelInternal& iModel;

   274         // Contains information of the Suplementary Services command.

   275         TPESSCommandInfo iSupplementaryServicesCommandInfo;     

   276         // Owned phone settings container.

   277         CPsetContainer* iSettings;

   278         // Owned phone settings ui container.

   279         CPsuiContainer* iObsContainer;

   280         // Owned call waiting.

   281         CPsetCallWaiting* iWaiting;

   282         // Owned waiting observer.

   283         CPsuiWaitingObs* iCwObserver;

   284         // Owned call barring.

   285         CPsetCallBarring* iBarring;

   286         // Owned call barring observer.

   287         CPsuiBarringObs* iCbObserver;

   288         // Owned call diverting.

   289         CPsetCallDiverting* iDivert;

   290         // Owned call diverting observer.

   291         CPsuiDivertObs* iCfObserver;

   292         // Owned calling line identity.

   293         CPsetCli* iCli;

   294         // Owned calling line identity observer.

   295         CPsuiCliObserver* iCliObserver;

   296 

   297     };

   298 

   299 #endif      // CPEPARSERSSHANDLER_H

   300             

   301 // End of File