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 CMMCUSTOMTSY_H

    21 #define CMMCUSTOMTSY_H

    22 

    23 #include <featmgr/featurecontrol.h>

    24 #include "cmmphonetsy.h"

    25 #include <ctsy/rmmcustomapi.h>

    26 #include "CMmCustomExtInterface.h"

    27 #include <ctsy/serviceapi/mcustomvendorextcomplete.h>

    28 #include "CMmSubTsyBase.h"

    29 #include "CMmTsyBase.h"

    30 #include "MmTsy_numberOfSlots.h"

    31 #include "MmTsy_timeoutdefs.h"

    32 #include <f32file.h>

    33 #include <hash.h>

    34 #include "cmmvoicecalltsy.h"

    35 

    36 // CONSTANTS

    37 // Valid range: 10-16

    38 #define BLOB_SIZE          16

    39 #define METADATA_SIZE      2

    40 

    41 // Rand database file paths

    42 _LIT( KRandDb, "rand_db.cur" );

    43 _LIT( KRandDbPrev, "rand_db.prv" );

    44 

    45 // FORWARD DECLARATIONS

    46 class CMmCustomExtInterface;

    47 class CMmCustomVendorExt;

    48 class CMmPacketTsy;

    49 

    50 // CLASS DECLARATION

    51 

    52 /**

    53  *  CMmCustomTsy contains mode-independent custom functionality and

    54  *  is an aggregate class for its subsystems.

    55  *

    56  */

    57 NONSHARABLE_CLASS( CMmCustomTsy ) : public CMmTsyBase, 

    58     public MCustomVendorExtComplete

    59     {

    60     friend class CMmWimTsy;

    61     friend class CMmSimLockTsy;

    62     friend class CMmSIMTsy;

    63     friend class CMmCustomSecurityTsy;

    64     friend class CMmPhonebookStoreTsy;

    65 

    66     // TCustomRequestType enumerates indexes to Custom TSY's request handle

    67     // table. Request handles are stored there while waiting for

    68     // completion of the request.

    69     enum TCustomRequestType

    70         {

    71         ECustomTsyReqHandleUnknown,

    72         ECustomTsyNotifyDtmfEvent,

    73         ECustomTsyGetDiagnosticInfo,

    74         ECustomTsyGetRemoteAlertingToneStatus,

    75         ECustomTsyCallOrigin,

    76         ECustomTsyTerminateCall,

    77         ECustomTsyGetAlsBlocked,

    78         ECustomTsySetAlsBlocked,

    79         ECustomTsyNotifyAlsBlockedChanged,

    80         ECustomTsyNotifyNSPSStatus,

    81         ECustomTsyGetCipheringInfo,

    82         ECustomTsyNotifyCipheringInfoChange,

    83         ECustomTsyNetWakeup,

    84         ECustomTsyNotifySsAdditionalInfo,

    85         ECustomTsyNotifySsRequestComplete,

    86         ECustomTsyNotifyCacheReady,

    87         ECustomTsyGetPndCacheStatus,

    88         ECustomTsyGetAlsPpSupport,

    89         ECustomTsyCallGsmBlackListClear,

    90         ECustomTsyCheckEmergencyNumber,

    91         ECustomTsyGetOperatorName,

    92         ECustomTsyGetProgrammableOperatorLogo,

    93         ECustomTsySsNotification,

    94         ECustomTsyGetNetworkOperatorName,

    95         ECustomTsyCheckTwoDigitDialSupport,

    96         ECustomTsySatRefreshCompleteNotification,

    97         ECustomTsyResetNetServer,

    98         ECustomTsyNotifyNetworkConnectionFailure,

    99         ECustomTsyGetSimFileInfo,

   100         ECustomTsyGetLifeTimerInfo,

   101         ECustomTsyGet3GPBInfo,

   102         ECustomTsyGetSystemNetworkModes,

   103         ECustomTsySetSystemNetworkMode,

   104         ECustomTsyGetCurrentSystemNetworkMode,

   105         ECustomTsyIMSAuthenticate,

   106         ECustomTsyGetSimAuthenticationData,

   107         ECustomTsySetDriveMode,

   108         ECustomTsyNotifyRauEvent,

   109         ECustomTsyReadHSxPAStatus,

   110         ECustomTsyWriteHSxPAStatus,

   111         ECustomTsyNotifyHSxPAStatus,

   112         ECustomTsyNotifyIccCallForwardingStatusChange,

   113         ECustomTsyGetIccCallForwardingStatus,

   114         ECustomTsyGetCellInfo,

   115         ECustomTsyNotifyCellInfoChange,

   116         ECustomTsyGetSystemNetworkBand,

   117         ECustomTsySetSystemNetworkBand,

   118 		ECustomTsyGetUSIMServiceSupport,

   119 		ECustomTsyNotifyRemoteAlertingToneStatusChange,

   120         // ATTENTION:: Declare constant for those requests that need

   121         // own request handle record in iTsyReqHandleStore above the

   122         // following!

   123         ECustomTsyMaxNumOfRequests

   124         };

   125 

   126     private:

   127     

   128         /** used for queuing CheckAlsPpSupport requests */

   129         struct TCheckAlsPpSupportRequest

   130             {

   131             /** ETel request handle */

   132             TTsyReqHandle iReqHandle; 

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

   134             RMmCustomAPI::TAlsSupport* iRetSupport; 

   135             };

   136         

   137         /** used for queuing GetSimFileInfo requests */

   138         struct TGetSimFileInfoRequest

   139             {

   140             /** ETel request handle */

   141             TTsyReqHandle iReqHandle; 

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

   143             TDes8* iSimFileInfo; 

   144             };

   145 

   146     public:

   147 

   148         /**

   149          * Two-phased constructor.

   150          *

   151          * @param aMmPhoneTsy Pointer to a MM PhoneTSY

   152          */

   153         static CMmCustomTsy* NewL( CMmPhoneTsy* aMmPhoneTsy );

   154 

   155         /**

   156          * Destructor

   157          */

   158         virtual ~CMmCustomTsy();

   159 

   160         /**

   161          * Deliver code.

   162          *

   163          * @param aCodes

   164          */

   165         void DeliverCodeL( RMobilePhone::TCodeAndUnblockCode aCodes );

   166 

   167         /**

   168          * Returns pointer to the Phone object

   169          *

   170          * @return Pointer to the Phone object

   171          */

   172         CMmPhoneTsy* Phone();

   173 

   174         /**

   175          * Returns pointer to CMmWim object.

   176          *

   177          * @return Pointer to base class of CMmWim object

   178          */

   179         CMmSubTsyBase* GetWimTsyPtr() { return iMmSubTsy[ESubTsyIdxWIM]; };

   180 

   181         /**

   182          * Returns pointer to CMmSs object.

   183          *

   184 

   185          * @return Pointer to base class of CMmSs object

   186          */

   187         CMmCustomExtInterface* GetActiveExtensionPtr()

   188             { return iMmCustomExtInterface; };

   189 

   190         /**

   191          * Returns pointer to CMmSimLockTsy object.

   192          *

   193          * @return Pointer to base class of CMmSimLockTsy object

   194          */

   195         CMmSubTsyBase* GetSimLockTsyPtr()

   196             { return iMmSubTsy[ESubTsyIdxSimLock]; };

   197 

   198         /**

   199          * Returns pointer to CMmSIMTsy object.

   200          *

   201          * @return Pointer to base class of CMmSIMTsy object

   202          */

   203         CMmSubTsyBase* GetSIMTsyPtr() { return iMmSubTsy[ESubTsyIdxSIM]; };

   204 

   205         /**

   206          * Returns pointer to CMmPacketTsy object.

   207          *

   208          * @return Pointer to base class of CMmPacketTsy object

   209          */

   210         CMmPacketTsy* PacketTsy()

   211             { return ( CMmPacketTsy* )iMmSubTsy[ESubTsyIdxPacket]; };

   212 

   213         /**

   214          * Gives pointer to the array of TSY's subsystems.

   215          *

   216          * @return Array of pointers to CMmSubTsyBase classes

   217          */

   218         virtual CMmSubTsyBase** GetSubsystemArrayPtr()

   219             { return &iMmSubTsy[0]; };

   220 

   221         /**

   222          * Gives the maximun number of TSY's subsystems.

   223          *

   224          * @return Number of subsystems

   225          */

   226         virtual TInt GetMaxNumberOfSubsystems() { return ESubTsyIdxMaxNum; };

   227 

   228         /**

   229          * TRAP's all CMmCustomTsy related Custom API requests in case that

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

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

   232          * TSY method call.

   233          *

   234          * @param aTsyReqHandle Request handle

   235          * @param aIpc IPC number of the request

   236          * @param aPackage Reference to a data package

   237          * @return KErrNone/KErrNotSupported

   238          */

   239         TInt ExtFunc ( const TTsyReqHandle aTsyReqHandle,

   240             const TInt aIpc,

   241             const TDataPackage& aPackage );

   242 

   243         /**

   244          * Handles extended client requests. Uses TRAP to ensure functioning

   245          * on memory allocation failure.

   246          *

   247          * @param aTsyReqHandle Request handle

   248          * @param aIpc IPC number of the request

   249          * @param aPackage Reference to a data package

   250          * @return Error value

   251          */

   252         virtual TInt DoExtFuncL( const TTsyReqHandle aTsyReqHandle,

   253             const TInt aIpc,

   254             const TDataPackage& aPackage );

   255 

   256         /**

   257          * Returns request mode for given IPC number.

   258          *

   259 

   260          * @param aIpc An interprocess communication command identifier

   261          * @return The ReqMode corresponding to given IPC

   262          */

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

   264 

   265         /**

   266          * Returns number of slots to be used for given IPC.

   267          *

   268          * @param aIpc An interprocess communication command identifier

   269          * @return The number of slots reserved for a given IPC

   270          */

   271         virtual TInt NumberOfSlotsL( const TInt aIpc );

   272 

   273         /**

   274          * Returns security policy for given IPC.

   275          *

   276          * @param aIpc An interprocess communication command identifier

   277          * @return Security policy for this IPC

   278          */

   279         virtual TSecurityPolicy GetRequiredPlatSecCaps( const TInt aIpc );

   280 

   281         /**

   282          * Cancels request of which IPC number and request handle are given in

   283          * parameters.

   284          *

   285          * @param aIpc An interprocess communication command identifier

   286          * @param aTsyReqHandle Request handle

   287          * @return Error value

   288          */

   289         virtual TInt CancelService( const TInt aIpc,

   290             const TTsyReqHandle aTsyReqHandle );

   291 

   292         /**

   293          * Register given notification.

   294          *

   295          * @param aIpc An interprocess communication command identifier

   296          * @return TInt KErrNotSupported

   297          */

   298         virtual TInt RegisterNotification( const TInt aIpc );

   299 

   300         /**

   301          * Deregister given notification.

   302          *

   303          * @param aIpc An interprocess communication command identifier

   304          * @return TInt KErrNotSupported

   305          */

   306         virtual TInt DeregisterNotification( const TInt aIpc );

   307 

   308         /**

   309          * Completes a CompleteTerminateCall request

   310          *

   311          * @param aError Error code

   312          */

   313         void CompleteTerminateCall( TInt aError );

   314 

   315         /**

   316          * Completes the GetCipheringInfoRequest

   317          *

   318          * @param aCipherIndStatus Status of ciphering indicator

   319          * @param aErrorCode Error code

   320          */

   321         void CompleteGetCipheringInfo( TBool aCipherIndStatus,

   322             TInt aErrorCode );

   323 

   324         /**

   325          * Completes a NetWakeup request

   326          *

   327          * @param aErrorCode Error code

   328          */

   329         void CompleteNetWakeup( TInt aErrorCode );

   330 

   331         /**

   332          * Completes a NotifyCipheringInfoChange request

   333          *

   334          * @param aCipherIndStatus Status of ciphering indicator

   335          * @param aCipherStatus Status of ciphering

   336          * @param aErrorCode Error code

   337          */

   338         void CompleteNotifyCipheringInfoChange( TBool aCipherIndStatus,

   339             TBool aCipherStatus,

   340             TInt aErrorCode );

   341 

   342         /**

   343          * Completes a NotifyNSPSStatus request

   344          *

   345          * @param aNspsStatus Status of NSPS (On/Off)

   346          */

   347         void CompleteNotifyNSPSStatus( TBool aNspsStatus );

   348 

   349         /**

   350          * Completes a GetAlsBlocked request

   351          *

   352          * @param aBlockStatus Status of ALS block

   353          * @param aErrorCode Error code

   354          */

   355         void CompleteGetAlsBlocked(

   356             RMmCustomAPI::TGetAlsBlockStatus aBlockStatus,

   357             TInt aErrorCode );

   358 

   359         /**

   360          * Completes a SetAlsBlocked request

   361          *

   362          * @param aErrorCode Error code

   363          */

   364         void CompleteSetAlsBlocked( TInt aErrorCode );

   365 

   366         /**

   367          * Completes a NotifyAlsBlockedChanged request

   368          *

   369          */

   370         void CompleteNotifyAlsBlockedChanged();

   371 

   372         /**

   373          * Completes a NotifyAlsBlockedChanged request

   374          *

   375 

   376          * @param aAlsSupport

   377          * @param aErrorCode Error code

   378          */

   379         void CompleteGetAlsPpSupport( RMmCustomAPI::TAlsSupport aAlsSupport,

   380             TInt aErrorCode );

   381 

   382         /**

   383          * Completes a NotifyDtmfEvent request

   384          *

   385 

   386          * @param aInfo Dtmf info

   387          * @param aErrorCode Error code

   388          */

   389         void CompleteNotifyDtmfEvent( RMmCustomAPI::TDtmfInfo aInfo,

   390             TInt aErrorCode );

   391 

   392         /**

   393          * Completes a ClearCallBlackListL request

   394          *

   395 

   396          * @param aErrorCode Error code

   397          */

   398         void CompleteClearCallBlackList( TInt aErrorCode );

   399 

   400         /**

   401          * Completes emergency number checking request

   402          *

   403 

   404          * @param aTelNumber Emergency number or NULL if check failed

   405          * @param aErrorValue Error value

   406          */

   407         void CompleteCheckEmergencyNumber(

   408             RMmCustomAPI::TMobileTelNumber* aTelNumber,

   409             TInt aErrorValue );

   410 

   411         /**

   412          * Completes get network provider name request

   413          *

   414 

   415          * @param aName Network provider name

   416          * @param aError Error value

   417          */

   418         void CompleteGetNetworkOperatorName( TDes* aName, TInt aError );

   419 

   420         /**

   421          * Completes the notification of SAT refresh to the client

   422          *

   423 

   424          */

   425         void CompleteSatRefreshCompleteNotification();

   426 

   427         /**

   428          * Notify RAU event

   429          *

   430          * @param aEventStatus RAU event status

   431          * @return Symbian error value

   432          */

   433         TInt NotifyRauEvent( RMmCustomAPI::TRauEventStatus* aEventStatus );

   434 

   435         /**

   436          * Completes RAU event notification

   437          *

   438          * @param aEventStatus RAU event status

   439          */

   440         void CompleteNotifyRauEvent(

   441                 RMmCustomAPI::TRauEventStatus aEventStatus,

   442                 TInt aErrorCode );

   443 

   444         /**

   445          * Cancels RAU event Notification

   446          *

   447          * @param aTsyReqHandle TSY reqhandle

   448          * @return Symbian error value

   449          */

   450         TInt NotifyRauEventCancel();

   451 

   452 #ifdef REQHANDLE_TIMER

   453         /**

   454          * Calls the needed complete method due timer expiration

   455          *

   456 

   457          * @param aReqHandleType Request handle type.

   458          * @param aError Error value

   459          * @param aIPC IPC value

   460          */

   461         void Complete( TInt aReqHandleType, TInt aError, TInt aIPC );

   462 #endif // REQHANDLE_TIMER

   463 

   464         /**

   465          * Completes checking of two digit dial support

   466          *

   467 

   468          * @param aTwoDigitDialSupport Two digit dial support status

   469          * @param aErrorCode Error code

   470          */

   471         void CompleteCheckTwoDigitDialSupport(

   472             RMmCustomAPI::TTwoDigitDialSupport aTwoDigitDialSupport,

   473             TInt aErrorCode );

   474 

   475         /**

   476          * Completes a requested NotifySsNetworkEvent

   477          *

   478 

   479          * @param aSsTypeAndMode ss type and mode

   480          * @param aSsInfo ss info

   481          * @param aErrorCode Error code

   482          */

   483         void CompleteNotifySsNetworkEvent(

   484             RMmCustomAPI::TSsTypeAndMode& aSsTypeAndMode,

   485             RMmCustomAPI::TSsInfo& aSsInfo,

   486             TInt aErrorCode );

   487 

   488         /**

   489          * Completes GetOperatorName

   490          *

   491 

   492          * @param aOperatorNameInfo Programmable operator name info

   493          * @param aErrorValue Error value

   494          */

   495         void CompleteGetOperatorName(

   496             RMmCustomAPI::TOperatorNameInfo& aOperatorNameInfo,

   497             TInt aErrorValue );

   498 

   499         /**

   500          * Completes GetProgrammableOperatorLogo

   501          *

   502 

   503          * @param aOperatorIdInfo Operator id

   504          * @param aLogoData Operator logo info

   505          * @param aErrorValue Error value

   506          */

   507         void CompleteGetProgrammableOperatorLogo(

   508             RMmCustomAPI::TOperatorId* aOperatorIdInfo,

   509             RMmCustomAPI::TOperatorLogo* aLogoData,

   510             TInt aErrorValue );

   511 

   512         /**

   513          * Sets SatRefresh Status

   514          *

   515 

   516          * @param aSatRefreshStatus SatRefresh status

   517          */

   518         IMPORT_C void SetSatRefreshStatus ( TBool aSatRefreshStatus );

   519 

   520         /**

   521          * Completes a ResetNetServer request

   522          *

   523 

   524          * @param aErrorValue Error value

   525          */

   526         void CompleteResetNetServer( TInt aErrorValue );

   527 

   528         /**

   529          * Completes a NotifyNetworkConnectionFailure request

   530          *

   531 

   532          */

   533         void CompleteNotifyNetworkConnectionFailure();

   534 

   535         /**

   536          * Completes SsRequestComplete notification

   537          *

   538 

   539          * @param aStatus SS status

   540          * @param aError Error variable

   541          */

   542         void CompleteSsRequestCompleteNotification( TInt aSsStatus,

   543             TInt aError );

   544 

   545         /**

   546          * Completes SsAdditionalInfo notification

   547          *

   548 

   549          * @param aSsAdditionalInfo

   550          * @param aError

   551          */

   552         void CompleteSsAdditionalInfoNotification(

   553             RMmCustomAPI::TSsAdditionalInfo* aSsAdditionalInfo,

   554             TInt aError );

   555 

   556         /**

   557          * Notifies client when Phonebook cache is ready

   558          *

   559 

   560          * @param aTsyReqHandle Request handle

   561          * @param aPndName Phonebookname

   562          * @return TInt KErrNone

   563          */

   564         TInt NotifyPhoneBookCacheReady( const TTsyReqHandle aTsyReqHandle,

   565             TName* aPndName );

   566 

   567         /**

   568          * Completes NotifyPhoneBookCacheReady notification

   569          *

   570 

   571          * @param aPndName Phonebookname

   572          * @param aResult

   573          */

   574         void CompleteNotifyPhoneBookCacheReady( TName& aPndName,

   575             TInt aResult );

   576 

   577         /**

   578          * Gets current status of caching

   579          *

   580 

   581          * @param aTsyReqHandle Request handle

   582          * @param aPndStatus Status of caching

   583          * @param aPndName Phonebookname

   584          * @return TInt KErrNone

   585          */

   586         TInt GetPndCacheStatus(const TTsyReqHandle aTsyReqHandle,

   587             RMmCustomAPI::TPndCacheStatus* aPndStatus,

   588             const TName* aPndName );

   589 

   590         /**

   591          * This method updates caching status

   592          *

   593 

   594          * @param aPndStatus Cache status

   595          * @param aPndName Phonebookname

   596          */

   597         void UpdateCacheStatus( RMmCustomAPI::TPndCacheStatus aPndStatus,

   598             TName& aPndName );

   599 

   600         /**

   601          * Cancels notify phonebook cache ready notification

   602          *

   603 

   604          * @param aTsyReqHandle TSY req handle

   605          * @return KErrNone

   606          */

   607         TInt NotifyPhoneBookCacheReadyCancel(

   608             const TTsyReqHandle aTsyReqHandle );

   609 

   610         /**

   611          * Completes a GetSimFileInfo request

   612          *

   613 

   614          * @param aData File-data retrieved from SIM

   615          * @param  Error value

   616          */

   617         void CompleteGetSimFileInfo( TDesC8* aData,

   618             TInt aError );

   619 

   620         /**

   621          * Completes a GetSimFileInfo request

   622 

   623          * @param aLifeTimerData Life timer information

   624          * @param Error value

   625          */

   626         void CompleteGetLifeTime(

   627             RMmCustomAPI::TLifeTimeData& aLifeTimerData,

   628             TInt aErrorValue );

   629 

   630         /**

   631          * Sets diagnostic octets when received

   632          *

   633 

   634          * @param aCallId Id of the call that has diagnostics

   635         * @param aDiags The diagnostic octets

   636          */

   637         void CompleteGetDiagnosticOctects( TInt aCallId,

   638             TUint8 aDiags );

   639 

   640         /**

   641          * Get supported network modes

   642          *

   643 

   644          * @param aTsyReqHandle Request handle

   645         * @param aSystemNetworkModes Pointer to network modes

   646          * @return Error value

   647          */

   648         TInt GetSystemNetworkModesL( const TTsyReqHandle aTsyReqHandle,

   649             TUint32* aSystemNetworkModes );

   650 

   651         /**

   652          * Complete GetSystemNetworkModes or CurrentNetworkMode request

   653          *

   654 

   655          * @param aSystemNetworkModes Network modes

   656          * @param aResult Error value

   657          */

   658         void CompleteGetSystemOrCurrentNetworkModes(

   659             TUint32 aSystemNetworkModes,

   660             TInt aResult );

   661 

   662         /**

   663          * Cancel GetSystemNetworkModes request

   664          *

   665 

   666          * @param aTsyReqHandle TSY req handle

   667          * @return Error value

   668          */

   669         TInt GetSystemNetworkModesCancel( const TTsyReqHandle aTsyReqHandle );

   670 

   671         /**

   672          * Set system network mode

   673          *

   674 

   675          * @param aTsyReqHandle Request handle

   676         * @param aSystemNetworkModeCaps Pointer to system network mode

   677          * @return Error value

   678          */

   679         TInt SetSystemNetworkModeL( const TTsyReqHandle aTsyReqHandle,

   680             RMmCustomAPI::TNetworkModeCaps* aSystemNetworkModeCaps );

   681 

   682         /**

   683          * Complete SetSystemNetworkMode request

   684          *

   685 

   686          * @param Error value

   687          */

   688         void CompleteSetSystemNetworkMode( TInt aResult );

   689 

   690         /**

   691          * Get currently selected network mode

   692          *

   693 

   694          * @param aTsyReqHandle Request handle

   695         * @param aNetworkMode Pointer to network mode

   696          * @return TInt KErrNone

   697          */

   698         TInt GetCurrentSystemNetworkModeL( const TTsyReqHandle aTsyReqHandle,

   699             TUint32* aNetworkMode );

   700 

   701         /**

   702          * Cancel GetCurrentSystemNetworkMode request

   703          *

   704 

   705          * @param aTsyReqHandle TSY req handle

   706          * @return TInt KErrNone

   707          */

   708         TInt GetCurrentSystemNetworkModeCancel(

   709             const TTsyReqHandle aTsyReqHandle );

   710 

   711         /**

   712 	     * Get network band

   713 	     *

   714 	     * @param aTsyReqHandle Request handle

   715 	     * @param aSystemNetworkBand Pointer to network bands

   716 	     * @return Error value

   717 	     */

   718 	    TInt GetSystemNetworkBandL( const TTsyReqHandle aTsyReqHandle,

   719 	        RMmCustomAPI::TBandSelection* aSystemNetworkBand,

   720 	        RMmCustomAPI::TNetworkModeCaps* aSystemNetworkMode );

   721 

   722 	    /**

   723 	     * Complete GetSystemNetworkBand request

   724 	     *

   725 	     * @param aSystemNetworkBand Network band

   726 	     * @param aResult Error value

   727 	     */

   728 	    void CompleteGetSystemNetworkBand(

   729 	        RMmCustomAPI::TBandSelection aSystemNetworkBand,

   730 	        RMmCustomAPI::TNetworkModeCaps aSystemNetworkMode,

   731 	        TInt aResult );

   732 	        

   733 	    /**

   734 	     * Cancel GetSystemNetworkBand request

   735 	     *

   736 	     * @param aTsyReqHandle TSY req handle

   737 	     * @return Error value

   738 	     */

   739 	    TInt GetSystemNetworkBandCancel( const TTsyReqHandle aTsyReqHandle );

   740 

   741 	    /**

   742 	     * Set system network band

   743 	     *

   744 	     * @param aTsyReqHandle Request handle

   745 	     * @param aSystemNetworkBand Pointer to system network band

   746          * @param aSystemNetworkModeCaps Pointer to system network mode

   747 	     * @return Error value

   748 	     */

   749 	    TInt SetSystemNetworkBandL( const TTsyReqHandle aTsyReqHandle,

   750 	        RMmCustomAPI::TBandSelection* aSystemNetworkBand,

   751 	        RMmCustomAPI::TNetworkModeCaps* aSystemNetworkModeCaps );

   752 	        

   753 	    /**

   754 	     * Complete SetSystemNetworkBand request

   755 	     *

   756 	     * @param Error value

   757 	     */

   758 	    void CompleteSetSystemNetworkBand( TInt aResult );

   759     

   760         /**

   761          * Completes sim authentication request

   762          *

   763          * @param aDataPackage Holds authentication data from sim

   764          * @param aResult Error value

   765          */

   766         void CompleteSimAuthentication( CMmDataPackage* aDataPackage,

   767             TInt aResult );

   768 

   769         /**

   770          * Completes ims authentication request

   771          *

   772          * @param aDataPackage Holds authentication data from sim

   773          * @param aResult Error value

   774          */

   775         void CompleteImsAuthentication( CMmDataPackage* aDataPackage,

   776             TInt aResult );

   777 

   778         /**

   779          * Completes a Set Drive Mode request

   780          *

   781          * @param aErrorCode

   782          */

   783         void CompleteSetDriveMode( TInt aErrorCode );

   784 

   785           /**

   786          * Completes Get Current System Network Mode

   787          *

   788          * @param aCurrentNetwork Network

   789          * @param aResult Result value

   790          */

   791         void CompleteGetCurrentSystemNetworkMode( TUint32 aCurrentNetwork,

   792             TInt aResult );

   793 

   794         /**

   795          * Saves call object for completion of emergency nbr check

   796          *

   797          * @param aCallObject call object

   798          */

   799         void SetObjectForISVDialNumberCheck( CMmVoiceCallTsy* aCallObject );

   800 

   801         /**

   802          * This checks whether given number is an emergency number

   803          *

   804          * @param aTsyReqHandle TSY req handle

   805          * @param aNumberMode Number to be checked and check mode

   806          * @param aResult Result of check

   807          * @return TInt KErrNone

   808          */

   809         TInt CheckEmergencyNumberL( const TTsyReqHandle aTsyReqHandle,

   810             RMmCustomAPI::TEmerNumberCheckMode* aNumberMode,

   811             TBool* aResult );

   812 

   813         /**

   814          * Complete ReadHSxPAStatus request

   815          *

   816          * @param aDataPackage Datapackage

   817          * @param aErrorCode Error code

   818          */

   819         void CompleteReadHSxPAStatus( CMmDataPackage* aDataPackage,

   820             TInt aErrorCode );

   821 

   822         /**

   823          * Complete WriteHSxPAStatus request

   824          *

   825          * @param aErrorCode Error code

   826          */

   827         void CompleteWriteHSxPAStatus( TInt aErrorCode );

   828 

   829         /**

   830          * Complete HSxPA Status notification

   831          *

   832          * @param aErrorCode Error code

   833          */

   834         void CompleteNotifyHSxPAStatus( CMmDataPackage* aDataPackage,

   835             TInt aErrorCode );

   836             

   837         /**

   838          * Get Icc Call forwarding parameters

   839          *

   840          * @param aTsyReqHandle reghandle

   841          * @param aCFIndicators pointer to client side data

   842          * @return error value

   843          */       

   844        	TInt GetIccCallForwardingStatusL( TTsyReqHandle aTsyReqHandle, 

   845        		TDes8* aCFIndicators );

   846        	

   847        	/**

   848          * Completes get icc CF status request

   849          *

   850          * @param aDataPackage data package

   851          * @param aErrorCode Error Code

   852          */	

   853        	void CompleteGetIccCallForwardingStatus( 

   854        		CMmDataPackage* aDataPackage,

   855        		TInt aErrorCode );

   856 

   857        	/**

   858          * Sets notification on for CF status change

   859          *

   860          * @param aCFIndicators pointer to client side data

   861          * @return error value

   862          */

   863 		TInt NotifyIccCallForwardingStatusChange( TDes8* aCFIndicators );

   864 			

   865 		/**

   866          * Completes icc CF status change notification

   867          *

   868          * @param aDataPackage data package

   869          * @param aErrorCode Error Code

   870          */

   871 		void CompleteNotifyIccCallForwardingStatusChange( 

   872 			CMmDataPackage* aDataPackage,

   873     		TInt aErrorCode );

   874     		

   875     	/**

   876          * Compares indicator packages 

   877          *

   878          * @param aNotifyCFIndicator indicator to be compared

   879          * @return Boolean indicating change

   880          */

   881     	TBool IsIccCallForwardingStatusChanged( 

   882     		RMmCustomAPI::TCFIndicators& aNotifyCFIndicator );

   883     	

   884     	/**

   885          * Cancels icc callforwarding notification

   886          *

   887          * @param aTsyReqHandle reghandle

   888          * @return error value

   889          */	

   890     	TInt NotifyIccCallForwardingStatusChangeCancel(

   891     		const TTsyReqHandle aTsyReqHandle );

   892     		

   893         /**

   894          * Complete cell info change notification

   895          *

   896          * @param aCellInfo pointer to client side data

   897          * @return error code

   898          */

   899         void CompleteNotifyCellInfoChange( 

   900             RMmCustomAPI::TMmCellInfo* aCellInfo,

   901             TInt aErrorCode  );

   902             

   903         /**

   904          * Completes an outstanding GetCellInfo request.

   905          *

   906          * @param aCellInfo pointer to client side data

   907          * @return error value

   908          */ 

   909         void CompleteGetCellInfo( RMmCustomAPI::TMmCellInfo* aCellInfo,

   910             TInt aErrorValue );

   911 

   912         /**

   913          * Get phonebook cache status

   914          *

   915          * @param aPhoneBookType Phonebooktype

   916          * @return Cache status

   917          */

   918 

   919         RMmCustomAPI::TPndCacheStatus GetPhonebookCacheStatus( 

   920             TUint8 aPhoneBookType );

   921 

   922         /**

   923          * From MCustomVendorExtComplete

   924          * Completes a request back to the client.

   925          *

   926          * @param aTsyReqHandle Request handle

   927          * @param aError Error code

   928          */

   929         void ReqCompleted( const TTsyReqHandle aTsyReqHandle, 

   930             const TInt aError ); 

   931         

   932         /**

   933          * Change the bootup flag of ICC Callforward.

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

   935          *

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

   937          */

   938         void SetIccCfBootUpFlag( TBool aBootUp ); 

   939 

   940         /**

   941          * Complete GetUSIMServiceSupport request

   942          *

   943          * @since S60 v3.2

   944          * @param aDataPackage Datapackage

   945          * @param aErrorCode Error code

   946          */

   947         void CompleteGetUSIMServiceSupport( CMmDataPackage* aDataPackage,

   948             TInt aErrorCode );

   949             

   950         /**

   951          * Notify RemoteAlertingToneStatusChange

   952          *

   953          * @param aToneStatus RemoteToneAlerting status

   954          * @return Symbian error value

   955          */

   956         TInt NotifyRemoteAlertingToneStatusChange( 

   957             RMmCustomAPI::TRemoteAlertingToneStatus* aToneStatus );

   958 

   959         /**

   960          * Completes NotifyRemoteAlertingToneStatusChange notification

   961          *

   962          * @param aToneStatus RemoteToneAlerting status

   963          * @param aErrorCode Error code

   964          */

   965         void CompleteNotifyRemoteAlertingToneStatusChange(

   966             RMmCustomAPI::TRemoteAlertingToneStatus aToneStatus,

   967             TInt aErrorCode );

   968 

   969         /**

   970          * Cancels RemoteAlertingToneStatusChange Notification

   971          *

   972          * @return Symbian error value

   973          */

   974         TInt NotifyRemoteAlertingToneStatusChangeCancel();

   975             

   976     private:

   977 

   978         /**

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

   980          *

   981          * @param aMmPhoneTsy Pointer to MM Phone Tsy object

   982          */

   983         void ConstructL( CMmPhoneTsy* aMmPhoneTsy );

   984 

   985         /**

   986          * C++ default constructor.

   987          */

   988         CMmCustomTsy();

   989 

   990         /**

   991          * Terminate call/all calls

   992          *

   993          * @param aTsyReqHandle TSY req handle

   994          * @param aCallName Name of the call(s) to be terminated

   995          * @return TInt KErrNone

   996          */

   997         TInt TerminateCallL( const TTsyReqHandle aTsyReqHandle,

   998             const TName* aCallName );

   999 

  1000         /**

  1001          * Notify Dtmf Event

  1002          *

  1003          * @param aInfo Dtmf info

  1004          * @return TInt KErrNone

  1005          */

  1006         TInt NotifyDtmfEvent( RMmCustomAPI::TDtmfInfo* aInfo );

  1007 

  1008         /**

  1009          * Cancel NotifyDtmfEvent request

  1010          *

  1011          * @param aTsyReqHandle TSY req handle

  1012          * @return TInt KErrNone

  1013          */

  1014         TInt NotifyDtmfEventCancel( const TTsyReqHandle aTsyReqHandle );

  1015 

  1016          /**

  1017          * Getting diagnostic info

  1018          *

  1019          * @param aTsyReqHandle TSY req handle

  1020          * @param aCallName Call name

  1021          * @return Error value

  1022          */

  1023         

  1024         TInt GetDiagnosticInfo( const TTsyReqHandle aTsyReqHandle,

  1025             TName* aCallName );

  1026 

  1027         /**

  1028          * Reads the remote alerting tone status

  1029          *

  1030          * @param aTsyReqHandle TSY req handle

  1031          * @param aToneStatus Tone status

  1032          * @return KErrNone

  1033          */

  1034         TInt GetRemoteAlertingToneStatus( const TTsyReqHandle aTsyReqHandle,

  1035             RMmCustomAPI::TRemoteAlertingToneStatus* aToneStatus );

  1036 

  1037         /**

  1038          * Returns the origin of the call

  1039          *

  1040          * @param aTsyReqHandle TSY req handle

  1041          * @param aCallName Call name

  1042          * @param aOrigin Call origin

  1043          * @return KErrNone

  1044          */

  1045         TInt GetCallOrigin( const TTsyReqHandle aTsyReqHandle,

  1046             TName* aCallName,

  1047             RMmCustomAPI::TCallOrigin* aOrigin );

  1048 

  1049         /**

  1050          * Gets alternating line service blocked status

  1051          *

  1052          * @param aTsyReqHandle TSY req handle

  1053          * @param aBlockStatus Block status

  1054          * @return KErrNone

  1055          */

  1056         TInt GetAlsBlockedL( const TTsyReqHandle aTsyReqHandle,

  1057             RMmCustomAPI::TGetAlsBlockStatus* aBlockStatus );

  1058 

  1059         /**

  1060          * Cancel GetAlsBlocked request

  1061          *

  1062          * @return KErrNone

  1063          */

  1064         TInt GetAlsBlockedCancel();

  1065 

  1066         /**

  1067          * Gets phonebook 3G info

  1068          *

  1069          * @param aTsyReqHandle TSY req handle

  1070          * @param aInfo 3G phonebook info

  1071          * @return KErrNone

  1072          */

  1073         TInt Get3GPBInfo( const TTsyReqHandle aTsyReqHandle,

  1074             RMmCustomAPI::T3GPBInfo* aInfo );

  1075 

  1076         /**

  1077          * Cancel Get3GPBInfo request

  1078          *

  1079          * @return KErrNone

  1080          */

  1081         TInt Get3GPBInfoCancel();

  1082 

  1083         /**

  1084          * Sets alternating line service blocked status

  1085          *

  1086          * @param aTsyReqHandle TSY req handle

  1087          * @param aBlockStatus Block status

  1088          * @return KErrNone

  1089          */

  1090         TInt SetAlsBlockedL( const TTsyReqHandle aTsyReqHandle,

  1091             RMmCustomAPI::TSetAlsBlock* aBlockStatus );

  1092 

  1093         /**

  1094          * Notifies a client of changed Als blocked status

  1095          *

  1096          * @param aTsyReqHandle TSY req handle

  1097          * @param aBlockStatus Block status

  1098          * @return KErrNone

  1099          */

  1100         TInt NotifyAlsBlockedChanged(

  1101             RMmCustomAPI::TGetAlsBlockStatus* aBlockStatus );

  1102 

  1103         /**

  1104          * Cancels an Outstanding NotifyAlsBlockedChanged

  1105          *

  1106          * @param aTsyReqHandle TSY req handle

  1107          * @return KErrNone

  1108          */

  1109         TInt NotifyAlsBlockedChangedCancel( 

  1110             const TTsyReqHandle aTsyReqHandle );

  1111 

  1112         /**

  1113          * Get ALS pp Support

  1114          *

  1115          * @param aTsyReqHandle TSY req handle

  1116          * @param aSupport

  1117          * @return KErrNone

  1118          */

  1119         TInt GetAlsPpSupportL( const TTsyReqHandle aTsyReqHandle,

  1120             RMmCustomAPI::TAlsSupport* aSupport );

  1121 

  1122         /**

  1123          * Cancels an outstanding GetAlsPpSupport function

  1124          *

  1125          * @return KErrNone

  1126          */

  1127         TInt GetAlsPpSupportCancel();

  1128 

  1129         /**

  1130          * Gets the ciphering info

  1131          *

  1132          * @param aTsyReqHandle TSY req handle

  1133          * @param aInfo Ciphering information

  1134          * @return KErrNone