telephonyserverplugins/common_tsy/commontsy/inc/mmtsy/cmmphonetsy.h
changeset 0 3553901f7fa8
child 5 7ef16719d8cb
equal deleted inserted replaced
-1:000000000000 0:3553901f7fa8
       
     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 CMMPHONETSY_H
       
    21 #define CMMPHONETSY_H
       
    22 
       
    23 //  INCLUDES
       
    24 #include <etelmm.h>
       
    25 #include <et_phone.h>
       
    26 #include <mmretrieve.h>
       
    27 #include <pcktcs.h>
       
    28 #include <e32property.h>
       
    29 #include <centralrepository.h>
       
    30 #include <ctsy/mltsyfactorybase.h>
       
    31 #include "cmmmessagemanagerbase.h"
       
    32 #include "MmTsy_timeoutdefs.h"
       
    33 #include <ctsy/serviceapi/mmtsy_defaults.h>
       
    34 #include <ctsy/tflogger.h>
       
    35 #include "CMmPrivateUtility.h"
       
    36 #include <ctsy/serviceapi/ctsydomainpskeys.h>
       
    37 #include <ctsy/serviceapi/mctsysatservice.h>
       
    38 #include <ctsy/pluginapi/mtelephonyaudiocontrolcallback.h>
       
    39 #include <hwrmpower.h>
       
    40 #include "BatteryInfoObserver.h"
       
    41 #include "ChargingStatusObserver.h"
       
    42 
       
    43 // FORWARD DECLARATIONS
       
    44 #ifdef REQHANDLE_TIMER
       
    45 class CResponseTimer;
       
    46 class CResponseTimerStore;
       
    47 #endif
       
    48 class CMmConferenceCallTsy;
       
    49 class CMmSmsTsy;
       
    50 class CMmBroadcastTsy;
       
    51 class CMmONStoreTsy;
       
    52 class CMmENStoreTsy;
       
    53 class CMmPhoneBookStoreTsy;
       
    54 class CStorageInfoData;
       
    55 class CTsySatMessagingBase;
       
    56 class CMmUssdTsy;
       
    57 class CMmCustomTsy;
       
    58 class CMmPacketServiceTsy;
       
    59 
       
    60 class CMmPhoneExtInterface;
       
    61 class CMmTsyReqHandleStore;
       
    62 class CMmCallList;
       
    63 class CMmLineList;
       
    64 class CMmPBList;
       
    65 
       
    66 class CMmCallTsy;
       
    67 class CHeartbeatRunner;
       
    68 class CMmNetTsy;
       
    69 class CMmDtmfTsy;
       
    70 class CMmSupplServTsy;
       
    71 class CMmSecurityTsy;
       
    72 class CMmCustomSecurityTsy;
       
    73 
       
    74 class CMmPhoneFactoryTsy;
       
    75 class CMmDataPackage;
       
    76 
       
    77 class MTelephonyAudioControl;
       
    78 
       
    79 // CLASS DECLARATION
       
    80 
       
    81 /**
       
    82  *  CMmPhoneTsy contains mode-independent phone functionality.
       
    83  *  Extension request handles and parameters are stored as attributes.
       
    84  */
       
    85  
       
    86 NONSHARABLE_CLASS( CMmPhoneTsy ) : public CPhoneBase,
       
    87                                    public MTelephonyAudioControlCallback,
       
    88                                    public MBatteryInfoNotifier,
       
    89                                    public MChargingStatusNotifier
       
    90     {
       
    91     
       
    92     public: // Friend classes
       
    93 
       
    94         /** Classes which also implement RMobilePhone functionality
       
    95             are declared as friends */
       
    96             
       
    97         friend class CMmNetTsy;
       
    98         friend class CMmDtmfTsy;
       
    99         friend class CMmSupplServTsy;
       
   100         friend class CMmSecurityTsy;
       
   101         
       
   102     public: // Enumerations
       
   103 
       
   104         /** Phone request types*/
       
   105         
       
   106         enum TPhoneRequestTypes
       
   107             {
       
   108             EMultimodePhoneReqHandleUnknown, //0
       
   109             EMultimodePhoneNotifyModemDetected,
       
   110             EMultimodePhoneCapsChangeNotification,
       
   111             EMultimodePhoneNotifyDTMFCaps,
       
   112             EMultimodePhoneSendDTMFTones,
       
   113             EMultimodePhoneStartDTMFTone, //5
       
   114             EMultimodePhoneStopDTMFTone,
       
   115             EMultimodePhoneSendNetworkServiceRequest,
       
   116             EMultimodePhoneGetDetectedNetworksPhase1, 
       
   117             EMultimodePhoneNotifyNetworkRegistrationStatusChange, 
       
   118             EMultimodePhoneNotifyModeChange, //10
       
   119             EMultimodePhoneNotifyCurrentNetworkChange, 
       
   120             EMultimodePhoneNotifySignalStrengthChange, 
       
   121             EMultimodePhoneNotifyNetworkTimeInfoChange, 
       
   122             EMultimodePhoneNotifyNWSelectionSettingChange, 
       
   123             EMultimodePhoneNotifyNWTimeInfoChange, //15
       
   124             EMultimodePhoneSelectNetwork, 
       
   125             EMultimodePhoneSetNWSelectionSetting, 
       
   126             EMultimodePhoneSetCallForwardingStatus, 
       
   127             EMultimodePhoneGetIdentityServiceStatus,
       
   128             EMultimodePhoneSetCallBarringStatus, //20
       
   129             EMultimodePhoneSetSSPassword,
       
   130             EMultimodePhoneSetCallWaitingStatus,
       
   131             EMultimodePhoneSetFdnSetting,
       
   132             EMultimodePhoneGetFdnStatus,
       
   133             EMultimodePhoneNotifyCallForwardingStatusChange,
       
   134             EMultimodePhoneNotifyCallBarringStatusChange,
       
   135             EMultimodePhoneNotifyCallWaitingStatusChange,
       
   136             EMultimodePhoneNotifyAlsLineChange, 
       
   137             EMultimodePhoneNotifyFdnStatusChange, 
       
   138             EMultimodePhoneGetCallForwardingStatusPhase1,
       
   139             EMultimodePhoneGetCallBarringStatusPhase1,
       
   140             EMultimodePhoneGetCallWaitingStatusPhase1, 
       
   141             EMultimodePhoneNotifySecurityCapsChange,
       
   142             EMultimodePhoneGetLockInfo, 
       
   143             EMultimodePhoneNotifyLockInfoChange,
       
   144             EMultimodePhoneSetLockSetting,
       
   145             EMultimodePhoneChangeSecurityCode,
       
   146             EMultimodePhoneNotifySecurityEvent,
       
   147             EMultimodePhoneVerifySecurityCode,
       
   148             EMultimodePhoneAbortSecurityCode,
       
   149             EMultimodePhoneNotifyBatteryInfoChange,
       
   150             EMultimodePhoneNotifyStopInDTMFString,
       
   151             EMultimodePhoneNotifyCallServiceCapsChange,
       
   152             EMultimodePhoneNotifyCallForwardingActive,
       
   153             EMultimodePhoneNotifyIccAccessCapsChange,
       
   154             EMultimodePhoneGetCustomerServiceProfile,
       
   155             EMultimodePhoneGetServiceTable, 
       
   156             EMultimodePhoneGetPhoneStoreInfo, 
       
   157             EMultimodePhoneOutOfMemory, 
       
   158             EMultimodePhoneGetAlsLine,
       
   159             EMultimodePhoneSetAlsLine,
       
   160             EMultimodePhoneGetNITZInfo,
       
   161             EMultimodePhoneGetCellInfo,
       
   162             EMultimodePhoneNotifyCellInfoChange,
       
   163             EMultimodePhoneGetServiceProviderName,
       
   164             EMultimodePhoneGetNetworkRegistrationStatus,
       
   165             EMultimodePhoneGetSubscriberId,
       
   166             EMultimodePhoneNotifyNetworkSecurityLevelChange,
       
   167             EMultimodePhoneGetCipheringIndicatorStatus,
       
   168             EMultimodePhoneGetBatteryInfo,
       
   169             EMultimodePhoneGetPhoneId,
       
   170             EMultimodePhoneNotifyCurrentNetworkNoLocationChange, 
       
   171             EMultimodePhoneNotifyIndicatorChange,
       
   172             EMultimodePhoneGetAuthorizationInfoPhase1,
       
   173             EMultimodePhoneIMSAuthenticate,
       
   174             EMultimodePhoneGetMailboxNumbers,
       
   175             EMultimodePhoneEnumerateAPNEntries,
       
   176             EMultimodePhoneGetAPNname,    
       
   177             EMultimodePhoneGetIccMessageWaitingIndicators,
       
   178             EMultimodePhoneSetIccMessageWaitingIndicators,
       
   179             EMultimodePhoneNotifyIccMessageWaitingIndicatorsChange,
       
   180             EMultimodePhoneGetSecurityCodeInfoPin1,
       
   181             EMultimodePhoneGetSecurityCodeInfoPin2,
       
   182             EMultimodePhoneGetSecurityCodeInfoPuk1,
       
   183             EMultimodePhoneGetSecurityCodeInfoPuk2,
       
   184             EMultimodePhoneGetSecurityCodeInfoPhonePassword,
       
   185             EMultimodePhoneGetSecurityCodeInfoSPC,
       
   186             EMultimodePhoneGetSecurityCodeInfoPhonebookHiddenKey,
       
   187             EMultimodePhoneGetSecurityCodeInfoUSIMAppPin,
       
   188             EMultimodePhoneGetSecurityCodeInfoSecondUSIMAppPin,
       
   189             EMultimodePhoneGetSecurityCodeInfoUniversalPin,
       
   190             EMultimodePhoneGetSecurityCodeInfoUniversalPuk,
       
   191             EMultimodePhoneNotifySecurityCodeInfoChange,
       
   192             EMultimodePhoneAppendAPNName,
       
   193             EMultimodePhoneDeleteAPNName,
       
   194             EMultimodePhoneNotifyAPNListChange,
       
   195             EMultimodePhoneSetAPNControlListServiceStatus,
       
   196             EMultimodePhoneGetAPNControlListServiceStatus,
       
   197             EMultimodePhoneNotifyAPNControlListServiceStatusChange,
       
   198             EMultimodePhoneSendNetworkServiceRequestNoFdnCheck,
       
   199             EMultimodePhoneNotifySendNetworkServiceRequest,
       
   200             EMultimodePhoneNotifyAllSendNetworkServiceRequest,
       
   201             EMultimodePhoneGetCurrentActiveUSimApplication,             
       
   202             EMultimodePhoneTerminateAllCalls,
       
   203             EMultimodePhoneNotifyDtmfEvent, 
       
   204             // ATTENTION:: Declare constant for those requests that need
       
   205             // own request handle record in iTsyReqHandleStore above the
       
   206             // following!
       
   207             EMultimodePhoneMaxNumOfRequests
       
   208             };
       
   209 
       
   210         class CNosBootState : public CBase
       
   211             {
       
   212             public:
       
   213                 TBool iSIMReady;
       
   214                 TBool iADNReady;
       
   215                 TBool iSecReady;
       
   216                 TBool iCachingActive;
       
   217             };
       
   218             
       
   219         /**
       
   220         * Every KLifeTimeUpdateInterval sec of the call, life time duration param is updated
       
   221         */
       
   222         enum { KLifeTimeUpdateInterval = 10	};                    
       
   223   
       
   224      public: // From MTelephonyAudioControlCallback
       
   225     
       
   226         /**
       
   227          * Informs errors from the Telephony Audio Control
       
   228          *
       
   229          * @param aCallName Call where the error happened
       
   230          * @param aError The error code
       
   231          */
       
   232         void NotifyTelephonyAudioControlError( const TName& aCallName, 
       
   233                                                const TInt& aError );
       
   234         
       
   235         /**
       
   236          * This method returns the information when modem status is ready
       
   237          *
       
   238          * @return ETrue if the modem is ready
       
   239          */
       
   240          TBool IsModemStatusReady() const;
       
   241          
       
   242     private:
       
   243 		  /** used for queuing GetServiceTable requests */
       
   244 		  struct TServiceTableRequests
       
   245 		      {
       
   246 		      /** ETel request handle */
       
   247 		      TTsyReqHandle iReqHandle;
       
   248 		      /** Table to be cached */ 
       
   249 		      RMobilePhone::TMobilePhoneServiceTable* iTable;
       
   250 		      /** Table to be cached */
       
   251 		      RMobilePhone::TMobilePhoneServiceTableV1* iTableData;	
       
   252 		      };
       
   253 		
       
   254           /** used for queuing GetSubscriberId requests */
       
   255           struct TSubscriberIdRequest
       
   256                {
       
   257                /** ETel request handle */
       
   258                TTsyReqHandle iReqHandle; 
       
   259                /** pointer to client-side    data*/
       
   260                RMobilePhone::TMobilePhoneSubscriberId* iRetSubscrId; 
       
   261                };
       
   262           
       
   263           /** used for queuing GetPhoneId requests */
       
   264           struct TGetPhoneIdRequest
       
   265                {
       
   266                /** ETel request handle */
       
   267                TTsyReqHandle iReqHandle; 
       
   268                /** pointer to client-side    data*/
       
   269                RMobilePhone::TMobilePhoneIdentityV1* iRetPhoneId; 
       
   270                };
       
   271                
       
   272           /**Used for queing GetServiceProviderName requests */       
       
   273           struct TServiceProviderNameRequest
       
   274                {
       
   275                /** ETel request handle */
       
   276                TTsyReqHandle iReqHandle;
       
   277                /** pointer to client side data */
       
   278                RMobilePhone::TMobilePhoneServiceProviderNameV2*
       
   279                    iServiceProviderName;     
       
   280                };
       
   281 
       
   282           /** Service table request types */
       
   283           enum TServiceTableRequest
       
   284                {
       
   285                ENoRequest,
       
   286                ESIMRequest,
       
   287                EUSIMRequest
       
   288                };
       
   289 
       
   290           struct TCustomerServiceProfileIdRequest
       
   291                {
       
   292                /** ETel request handle */
       
   293                TTsyReqHandle iReqHandle; 
       
   294                /** pointer to client-side    data */
       
   295                RMobilePhone::TMobilePhoneCspFileV1* iRetCspFile; 
       
   296                };
       
   297             
       
   298           struct TGetServiceTableRequest
       
   299                {
       
   300                /** ETel request handle */
       
   301                TTsyReqHandle iReqHandle;
       
   302                /** Table to be cached */ 
       
   303                RMobilePhone::TMobilePhoneServiceTable* iTable;
       
   304                /** Table to be cached */
       
   305                RMobilePhone::TMobilePhoneServiceTableV1* iTableData; 
       
   306                //** Cache done for this req*/
       
   307                TBool iCaching;
       
   308                };
       
   309                
       
   310           struct TGetAlsLineRequest
       
   311                {
       
   312                /** ETel request handle */
       
   313                TTsyReqHandle iReqHandle; 
       
   314                /** pointer to client-side    data */
       
   315                RMobilePhone::TMobilePhoneALSLine* iALSLine; 
       
   316                };
       
   317 
       
   318     public:  // Constructors and destructor
       
   319 
       
   320         /**
       
   321          * Two-phased constructor.
       
   322          *          
       
   323          *
       
   324          * @param aMessageManager: Pointer to the message manager. The returned 
       
   325          * 		CMmPhoneTsy takes ownership of this parameter.
       
   326          * @param aMmPhoneFactoryTsy Pointer to the phone factory (which is needed
       
   327          * 		for Sim Atk TSY creation). The returned CMmPhoneTsy does not take
       
   328          * 		ownership of this parameter. 
       
   329          * @param aFactory Pointer Ltsy factory base. The returned CMmPhoneTsy
       
   330          * 		takes ownership of this parameter.
       
   331          * return created phone object 
       
   332          */
       
   333         IMPORT_C static CMmPhoneTsy* NewL(         
       
   334             CMmMessageManagerBase* aMessageManager,
       
   335             CMmPhoneFactoryTsy* aMmPhoneFactoryTsy,
       
   336             MLtsyFactoryBase* aFactory );
       
   337 
       
   338         /**
       
   339          * Destructor.
       
   340          */
       
   341         virtual ~CMmPhoneTsy();
       
   342 
       
   343         // New functions
       
   344 
       
   345         /**
       
   346          * Initialisation method that is called from ETel Server.
       
   347          *          
       
   348          *
       
   349          */
       
   350         virtual void Init();
       
   351 
       
   352         /**
       
   353          * Creates new object by name and returns a pointer to it.
       
   354          *          
       
   355          *
       
   356          * @param aNewName 
       
   357          * return pointer to the created object
       
   358          */
       
   359         virtual CTelObject* OpenNewObjectByNameL( const TDesC& aName );
       
   360     
       
   361         /**
       
   362          * Creates new Line object and returns a pointer to it. All 
       
   363          * objects opened from the phone are opened by name, hence 
       
   364          * this method is NOT SUPPORTED.
       
   365          *          
       
   366          *
       
   367          * @param aNewName 
       
   368          * return pointer to the created object
       
   369          */
       
   370         virtual CTelObject* OpenNewObjectL( TDes& aNewName );
       
   371 
       
   372         /**
       
   373          * Dispatches multimode API functions calls
       
   374          *          
       
   375          *
       
   376          * @param aTsyReqHandle TSY request handle
       
   377          * @param aIpc request IPC number
       
   378          * @param aPackage packaged request parameters
       
   379          * @return result of the request
       
   380          */
       
   381         virtual TInt ExtFunc( const TTsyReqHandle aTsyReqHandle, 
       
   382             const TInt aIpc, 
       
   383             const TDataPackage& aPackage );
       
   384 
       
   385         /**
       
   386          * Returns request mode for given IPC.
       
   387          *          
       
   388          *
       
   389          * @param aIpc IPC number
       
   390          * @return request mode
       
   391          */
       
   392         virtual CTelObject::TReqMode ReqModeL( const TInt aIpc );
       
   393     
       
   394         /**
       
   395          * Returns number of slots to be used for given IPC
       
   396          *          
       
   397          *
       
   398          * @param aIpc request IPC number
       
   399          * @return result of the request
       
   400          */
       
   401         virtual TInt NumberOfSlotsL( const TInt aIpc );
       
   402 
       
   403         /**
       
   404          * Cancels request that's IPC number and request handle are given in
       
   405          * parameters
       
   406          *          
       
   407          *
       
   408          * @param aIpc request IPC number
       
   409          * @param aTsyReqHandle TSY request handle
       
   410          * @return result of the request
       
   411          */
       
   412         virtual TInt CancelService( const TInt aIpc, 
       
   413             const TTsyReqHandle aTsyReqHandle );
       
   414     
       
   415         /**
       
   416          * Fills the given pointer with phone information (core)
       
   417          *          
       
   418          *
       
   419          * @param aTsyReqHandle TSY request handle
       
   420          * @param aPhoneInfo phone information
       
   421          * @return Return value to the ETel Server
       
   422          */
       
   423         virtual TInt GetInfo( const TTsyReqHandle aTsyReqHandle, 
       
   424             RPhone::TPhoneInfo* aPhoneInfo );
       
   425     
       
   426         /**
       
   427          * Request for caps change notifications
       
   428          *          
       
   429          *
       
   430          * @param aTsyReqHandle TSY request handle
       
   431          * @param aCaps phone caps
       
   432          * @return Return value to the ETel Server
       
   433          */
       
   434         virtual TInt NotifyCapsChange( const TTsyReqHandle aTsyReqHandle, 
       
   435             RPhone::TCaps* aCaps );
       
   436     
       
   437         /**
       
   438          * Cancels caps change notifications
       
   439          *          
       
   440          *
       
   441          * @param aTsyReqHandle TSY request handle
       
   442          * @return Return value to the ETel Server
       
   443          */
       
   444         virtual TInt NotifyCapsChangeCancel( 
       
   445             const TTsyReqHandle aTsyReqHandle );
       
   446     
       
   447         /**
       
   448          * Controlled initialisation
       
   449          *          
       
   450          *
       
   451          * @param aTsyReqHandle TSY request handle
       
   452          * @return Return value to the ETel Server
       
   453          */
       
   454         virtual TInt ControlledInitialisation( 
       
   455             const TTsyReqHandle aTsyReqHandle );
       
   456     
       
   457         /**
       
   458          * Cancels controlled initialisation
       
   459          *          
       
   460          *
       
   461          * @param aTsyReqHandle TSY request handle
       
   462          * @return Return value to the ETel Server
       
   463          */
       
   464         virtual TInt ControlledInitialisationCancel( 
       
   465             const TTsyReqHandle aTsyReqHandle );
       
   466     
       
   467         /**
       
   468          * Request for modem detected notifications.
       
   469          *          
       
   470          *
       
   471          * @param aTsyReqHandle Request handle
       
   472          * @param aDetection Ptr to TModemDetection 
       
   473          * object
       
   474          * @return KErrNone
       
   475          */
       
   476         virtual TInt NotifyModemDetected( const TTsyReqHandle aTsyReqHandle, 
       
   477             RPhone::TModemDetection* aDetection );
       
   478         
       
   479         /**
       
   480          * Cancels modem detected notifications.
       
   481          *          
       
   482          *
       
   483          * @param aTsyReqHandle Request handle
       
   484          * @return KErrNone
       
   485          */
       
   486         virtual TInt NotifyModemDetectedCancel( 
       
   487             const TTsyReqHandle aTsyReqHandle );
       
   488         
       
   489         /**
       
   490          * Fills the given pointer with phone capabilities (core)
       
   491          *          
       
   492          *
       
   493          * @param aTsyReqHandle TSY request handle
       
   494          * @param aCaps phone capabities
       
   495          * @return Return value to the ETel Server
       
   496          */
       
   497         virtual TInt GetCaps( const TTsyReqHandle aTsyReqHandle, 
       
   498             RPhone::TCaps *aCaps );
       
   499 
       
   500         /**
       
   501          * Fills the given pointer with phone status (core)
       
   502          *          
       
   503          *
       
   504          * @param aTsyReqHandle TSY request handle
       
   505          * @param aStatus phone status
       
   506          * @return Return value to the ETel Server
       
   507          */
       
   508         virtual TInt GetStatus( const TTsyReqHandle aTsyReqHandle, 
       
   509             RPhone::TStatus *aStatus );
       
   510     
       
   511         /**
       
   512          * Fills the given pointer with maximum number of supported lines
       
   513          *          
       
   514          *
       
   515          * @param aTsyReqHandle TSY request handle
       
   516          * @param aCount line count
       
   517          * @return Return value to the ETel Server
       
   518          */
       
   519         virtual TInt EnumerateLines( const TTsyReqHandle aTsyReqHandle, 
       
   520             TInt *aCount );
       
   521     
       
   522         /**
       
   523          * Fills the given pointer with line information
       
   524          *          
       
   525          *
       
   526          * @param aTsyReqHandle: TSY request handle
       
   527          * @param aLineInfo: line information
       
   528          * @return TInt: Return value to the ETel Server
       
   529          */
       
   530         virtual TInt GetLineInfo(  const TTsyReqHandle aTsyReqHandle, 
       
   531           TLineInfoIndex *aLineInfo );
       
   532 
       
   533         /**
       
   534          * Register given notification
       
   535          *          
       
   536          *
       
   537          * @param aIpc IPC number
       
   538          * @return Return value to the ETel Server
       
   539          */
       
   540         virtual TInt RegisterNotification( const TInt aIpc );
       
   541     
       
   542         /**
       
   543          * Deregister given notification
       
   544          *          
       
   545          *
       
   546          * @param aIpc IPC number
       
   547          * @return Return value to the ETel Server
       
   548          */
       
   549         virtual TInt DeregisterNotification( const TInt aIpc );
       
   550         
       
   551         /**
       
   552          * Completes caps change notification
       
   553          *          
       
   554          *
       
   555          * @param None
       
   556          */
       
   557         void CompleteNotifyCapsChange();
       
   558 
       
   559         /**
       
   560          * Complete the client request when modem has been detected.
       
   561          *          
       
   562          *
       
   563          * @param aModemStatus Modem status
       
   564          */
       
   565         virtual void CompleteNotifyModemDetected( 
       
   566             RPhone::TStatus aModemStatus );
       
   567 
       
   568         /**
       
   569          * Returns the active phone extension
       
   570          *          
       
   571          *
       
   572          * @return pointer to the active phone extension
       
   573          */
       
   574         virtual CMmPhoneExtInterface* GetActivePhoneExtension();
       
   575 
       
   576         /**
       
   577          * Returns a pointer to the call list
       
   578          *          
       
   579          *
       
   580          * @return pointer to call list
       
   581          */
       
   582         virtual CMmCallList* CallList();
       
   583 
       
   584         /**
       
   585          * Returns a pointer to the line list
       
   586          *          
       
   587          *
       
   588          * @return pointer to line list
       
   589          */
       
   590         virtual CMmLineList* LineList();
       
   591 
       
   592         /**
       
   593          * Returns a pointer to the line list
       
   594          * 
       
   595          *                  
       
   596          * @return pointer to phonebook list
       
   597          */
       
   598         virtual CMmPBList* PBList();
       
   599 
       
   600         /**
       
   601          * Sets pointer to the conference call
       
   602          *          
       
   603          *
       
   604          * @param aMmConferenceCallTsy pointer to CC object
       
   605          */
       
   606         virtual void SetConferenceCall(
       
   607             CMmConferenceCallTsy* aMmConferenceCallTsy );
       
   608 
       
   609         /**
       
   610          * Returns pointer to the conference call
       
   611          *          
       
   612          *
       
   613          * @return pointer to conference call
       
   614          */
       
   615         virtual CMmConferenceCallTsy* ConferenceCall();
       
   616        
       
   617         /**
       
   618          * Notifies client about ALS line change
       
   619          *          
       
   620          *
       
   621          */
       
   622         virtual void CompleteNotifyALSLineChange( );
       
   623 
       
   624         /**
       
   625          * Completes the fdn setting request
       
   626          *          
       
   627          *
       
   628          * @param aErrorCode error/success code
       
   629          */
       
   630         virtual void CompleteSetFdnSettingL( TInt aErrorCode );
       
   631         
       
   632         /**
       
   633          * Notifies client about fdn status change
       
   634          *          
       
   635          *
       
   636          */
       
   637         virtual void CompleteNotifyFdnStatusChange( );
       
   638 
       
   639         /**
       
   640          * Completes the fdn status request
       
   641          *          
       
   642          *
       
   643          * @param aErrorCode error/success code
       
   644          */
       
   645         virtual void CompleteGetFdnStatus( CMmDataPackage* aDataPackage,
       
   646             TInt aErrorCode );
       
   647 
       
   648         /**
       
   649          * Completes client GetSubcriberId request
       
   650          *          
       
   651          *
       
   652          * @param aImsiData IMSI code
       
   653          * @param aError error/success code
       
   654          */
       
   655         virtual void CompleteGetSubscriberIdL( 
       
   656             TBuf8<RMobilePhone::KIMSISize> aImsiData,
       
   657             TInt aError );
       
   658 
       
   659         /**
       
   660          * Completes initialization of the phone
       
   661          *          
       
   662          *
       
   663          */
       
   664         virtual void CompleteNotifyModemStatusReady();
       
   665 
       
   666         /**
       
   667          * Initializes SIM dependent parts
       
   668          *          
       
   669          *
       
   670          */
       
   671         virtual void CompleteNotifySimStatusReadyL();
       
   672 
       
   673         /**
       
   674          * Sets the boot security flag iSecReady to ETrue
       
   675          *          
       
   676          *
       
   677          */
       
   678         void CompleteNotifySecurityReady();
       
   679 
       
   680         /**
       
   681          * Initializes Phonebook caching, this happens after SIM is ready
       
   682          *          
       
   683          *
       
   684          */
       
   685         void StartPBCachingL();
       
   686 
       
   687         /**
       
   688          * Returns current DOS bootstate
       
   689          *          
       
   690          *
       
   691          * @return DOS boot state
       
   692          */
       
   693         virtual CMmPhoneTsy::CNosBootState* NosBootState();
       
   694 
       
   695         /**
       
   696          * Returns current Phonebook state
       
   697          *          
       
   698          *
       
   699          * @return pointer to pb state -class
       
   700          */
       
   701         virtual CStorageInfoData* PhoneBookState();
       
   702 
       
   703         /**
       
   704          * Sets new DOS bootstate
       
   705          *          
       
   706          *
       
   707          * @param aNewState new state
       
   708          */
       
   709         virtual void SetNosBootState( CMmPhoneTsy::CNosBootState* aNewState );
       
   710 
       
   711         /**
       
   712          * Returns a pointer to active phone extension.
       
   713          *          
       
   714          *
       
   715          * @return pointer to requested object
       
   716          */
       
   717         CMmPhoneExtInterface* PhoneExtInterface();
       
   718 
       
   719         /**
       
   720          * Sets iPhoneIdentitys iSerialNumber
       
   721          *          
       
   722          *
       
   723          * @param aSerialData serial number
       
   724          * @param aError error code
       
   725          */
       
   726         virtual void CompleteGetPhoneId( 
       
   727             TBuf8<KSerialNumberLength> aSerialData, 
       
   728             TInt aError );
       
   729             
       
   730         /**
       
   731          * Cancels get phone id request 
       
   732          *          
       
   733          *
       
   734          * @param aTsyReqHandle TSY request handle
       
   735          * @return Result of the request
       
   736          */
       
   737         TInt MobilePhoneGetPhoneIdCancel( const TTsyReqHandle aTsyReqHandle );            
       
   738 
       
   739         /**
       
   740          * Returns pointer to the message manager
       
   741          *          
       
   742          *
       
   743          * @return pointer to the requested object
       
   744          */
       
   745         virtual CMmMessageManagerBase* MessageManager();
       
   746 
       
   747         /**
       
   748          * Returns pointer to the SMS session
       
   749          *          
       
   750          *
       
   751          * @param None
       
   752          * @return pointer to the SmsSession
       
   753          */
       
   754         virtual CMmSmsTsy* SmsSession();
       
   755 
       
   756         /**
       
   757          * Returns pointer to the SMS service as a MCtsySatService.
       
   758          *          
       
   759          *
       
   760          * @return pointer to the SmsService
       
   761          */
       
   762         virtual MCtsySatService& SmsService();
       
   763         
       
   764         /**
       
   765          * Set SMS session
       
   766          *          
       
   767          *
       
   768          * @param aMmSmsTsy
       
   769          */
       
   770         virtual void SetSmsSession( CMmSmsTsy* aMmSmsTsy );
       
   771 
       
   772         /**
       
   773          * Returns pointer to the Packet Data session
       
   774          *          
       
   775          *
       
   776          * @param None
       
   777          * @return pointer to the Packet Data session
       
   778          */
       
   779         virtual CMmPacketServiceTsy* PacketDataSession();
       
   780 
       
   781         /**
       
   782          * Sets Packet Data pointer to NULL
       
   783          *          
       
   784          *
       
   785          * @param None
       
   786          */
       
   787         virtual void ResetPacketDataSession();
       
   788 
       
   789         /**
       
   790          * Returns pointer to the SmsTsy
       
   791          *          
       
   792          *
       
   793          * @return pointer to the SmsTsy
       
   794          */
       
   795         virtual CMmSmsTsy* GetSmsTsy();
       
   796         
       
   797         /**
       
   798          * Returns pointer to the CustomTsy
       
   799          *          
       
   800          *
       
   801          * @return pointer to the CustomTsy
       
   802          */
       
   803         virtual CMmCustomTsy* GetCustomTsy();
       
   804 
       
   805         /**
       
   806          * Set pointer to the CustomTsy
       
   807          *          
       
   808          *
       
   809          * @param aMmCustomTsy
       
   810          */
       
   811         virtual void SetCustomTsy( CMmCustomTsy* aMmCustomTsy );
       
   812 
       
   813         /**
       
   814          * Complete notify ICC access capabilities change
       
   815          *          
       
   816          *
       
   817          * @param TInt aErrorCode Error code
       
   818          */
       
   819         virtual void CompleteNotifyIccAccessCapsChange();
       
   820 
       
   821         /**
       
   822          * Complete Get Customer Service Profile
       
   823          *          
       
   824          *
       
   825          * @param aCspFile CSP result from SIM
       
   826          * @param aErrorCode error code
       
   827          */
       
   828         virtual void CompleteGetCustomerServiceProfile( 
       
   829             RMobilePhone::TMobilePhoneCspFileV1 aCspFile,
       
   830             TInt aErrorCode );
       
   831 
       
   832         /**
       
   833          * This function cancels an outstanding ICC caps change 
       
   834          * notification request
       
   835          *          
       
   836          *
       
   837          * @param aTsyReqHandle Request handle
       
   838          * @return KErrNone
       
   839          */
       
   840         TInt NotifyIccAccessCapsChangeCancel( 
       
   841             const TTsyReqHandle aTsyReqHandle );
       
   842 
       
   843         /**
       
   844          * Complete Get Service Table
       
   845          *          
       
   846          *
       
   847          * @param aTableData result from SIM
       
   848          * @param aErrorCode error code
       
   849          */
       
   850         virtual void CompleteGetServiceTableL( 
       
   851             RMobilePhone::TMobilePhoneServiceTableV1 aTableData,
       
   852             TInt aErrorCode );
       
   853 
       
   854         /**
       
   855          * Complete Get Phone Store Info
       
   856          *          
       
   857          *
       
   858          * @param aPhoneStoreInfo Result from SIM
       
   859          * @param aErrorCode error code
       
   860          */
       
   861         virtual void CompleteGetPhoneStoreInfo( 
       
   862             RMobilePhoneStore::TMobilePhoneStoreInfoV1 aPhoneStoreInfo, 
       
   863             TInt aErrorCode );
       
   864         
       
   865         /**
       
   866          * This function completes battery informations.
       
   867          *          
       
   868          *
       
   869          * @param aDataPackage data package
       
   870          * @param aErrorCode error code      
       
   871          */
       
   872         void CompleteNotifyBatteryInfoChange(
       
   873             CMmDataPackage* aDataPackage,
       
   874             TInt aErrorCode );
       
   875 
       
   876         /**
       
   877          * Complete Get ServiceProvider Name
       
   878          *          
       
   879          *
       
   880          * @param aDataPackage
       
   881          * @param aErrorCode error code
       
   882          */
       
   883         virtual void CompleteGetServiceProviderName(
       
   884             CMmDataPackage* aDataPackage, TInt aErrorCode );
       
   885 
       
   886         /**
       
   887          * This method can be used to find out what protocol mode is
       
   888          * currently active.
       
   889          *          
       
   890          *         
       
   891          * @param aMode Mode
       
   892          */
       
   893         virtual void GetStaticExtensionMode( 
       
   894             RMobilePhone::TMobilePhoneNetworkMode* aMode );
       
   895 
       
   896         /**
       
   897          * Removes a line form LineList and recalculates phone capabilities.
       
   898          * Checks the mode from all 
       
   899          * lines and then defines the capabilities.
       
   900          *          
       
   901          *
       
   902          * @param aLineName
       
   903          */
       
   904         void RemoveLine( const TName &aLineName );
       
   905 
       
   906         /**
       
   907          * Sets pointer to call object wishing to answer incoming data call.
       
   908          *          
       
   909          *
       
   910          * @param aMmCall
       
   911          * @return Call object
       
   912          */
       
   913         void SetWaitingCallForData( CMmCallTsy* aMmCall );
       
   914 
       
   915         /**
       
   916          * Returns pointer to call object wishing to answer incoming data call
       
   917          *          
       
   918          *
       
   919          * @param None
       
   920          * @return Call object
       
   921          */
       
   922         CMmCallTsy* WaitingCallForData();
       
   923 
       
   924 #ifdef REQHANDLE_TIMER
       
   925         /**
       
   926          * Called when the timer expires and a request must be completed
       
   927          * automatically
       
   928          *          
       
   929          *
       
   930          * @param aReqHandleType req handle type.
       
   931          * @param aObject object that should handle this
       
   932          * @param aIPC
       
   933          */
       
   934         virtual void TimerExpired( CTelObject *aObject, TInt aReqHandleType, 
       
   935             TInt aIPC );
       
   936        
       
   937         /**
       
   938          * Calls the needed complete method due timer expiration
       
   939          *          
       
   940          *
       
   941          * @param aReqHandleType req handle type.
       
   942          * @param aError error value
       
   943          */
       
   944         void Complete( TInt aReqHandleType, TInt aError );
       
   945 
       
   946         /**
       
   947          * Gets the pointer to the private member attribute iTimeStampStore
       
   948          *          
       
   949          *
       
   950          * @return pointer to the time stamp store
       
   951          */
       
   952         virtual CResponseTimerStore* GetTimeStampStore();
       
   953 
       
   954         /**
       
   955          * gets the pointer to the member private attribute iReqHandleTimer
       
   956          *          
       
   957          *
       
   958          * @return pointer to the the iReqHandleTimer
       
   959          */
       
   960         virtual CResponseTimer* GetTimer();
       
   961 #endif
       
   962 
       
   963         /**
       
   964          * Completes GetAlsLine
       
   965          *          
       
   966          *
       
   967          * @param aAlsStatus ALS line status
       
   968          * @param aErrorCode Symbian OS error code
       
   969          */
       
   970         virtual void CompleteGetAlsLine( 
       
   971             RMobilePhone::TMobilePhoneALSLine aAlsStatus, TInt aErrorCode );
       
   972         /**
       
   973          * Completes SetAlsLine
       
   974          *          
       
   975          *
       
   976          * @param aErrorCode Symbian OS error code
       
   977          */
       
   978         virtual void CompleteSetAlsLine( TInt aErrorCode );
       
   979 
       
   980         /**
       
   981          * Cancels an outstanding GetAlsLine request
       
   982          *          
       
   983          *
       
   984          */
       
   985         virtual TInt GetAlsLineCancel ( const TTsyReqHandle aTsyReqHandle );
       
   986 
       
   987         /**
       
   988          * Starts the air time duration timer
       
   989          *          
       
   990          *
       
   991          */
       
   992         virtual void AirTimeTimerCheckStart();
       
   993 
       
   994         /**
       
   995          * Starts the air time duration timer
       
   996          *          
       
   997          *
       
   998          */
       
   999         virtual void AirTimeTimerCheckStop();
       
  1000 
       
  1001         /**
       
  1002          * Gets the value of the air time duration timer
       
  1003          *          
       
  1004          *
       
  1005          * @param aTime value of the air time duration
       
  1006          */
       
  1007         virtual void GetAirTimeDuration( TTimeIntervalSeconds& aTime );
       
  1008 
       
  1009         /**
       
  1010          * Returns pointer to the SAT messaging
       
  1011          *          
       
  1012          *
       
  1013          * @return pointer to SAT messaging
       
  1014          */
       
  1015         virtual MStkTsySatService* GetSatMessaging();
       
  1016 
       
  1017         /**
       
  1018          * Get State Info
       
  1019          *          
       
  1020          *
       
  1021          * @return TRfStateInfo state info
       
  1022          */
       
  1023         virtual TRfStateInfo GetRfStateInfo();
       
  1024 
       
  1025         /**
       
  1026          * Set State Info
       
  1027          *          
       
  1028          *
       
  1029          * @param aStateInfo state info
       
  1030          */
       
  1031         virtual void SetRfStateInfo( TRfStateInfo aStateInfo );
       
  1032 
       
  1033         /**
       
  1034          * Set Rf Status
       
  1035          *          
       
  1036          *
       
  1037          * @param aRfStatus rf status
       
  1038          */
       
  1039         virtual void SetRfStatus( TRfStatus aRfStatus );
       
  1040 
       
  1041         /**
       
  1042          * Get Rf Status
       
  1043          *          
       
  1044          *
       
  1045          * @return iRfStatusFlag rf status
       
  1046          */
       
  1047         virtual TRfStatus GetRfStatus();
       
  1048 
       
  1049         /**
       
  1050          * Registers SIM files for refresh
       
  1051          *          
       
  1052          *
       
  1053          * @return Error value
       
  1054          */
       
  1055         TInt SimRefreshRegisterL();
       
  1056         
       
  1057         /**
       
  1058          * Completes the SIM refresh register
       
  1059          *          
       
  1060          *
       
  1061          * @param aErrorCode Symbian OS error code
       
  1062          */
       
  1063         void CompleteSimRefreshRegister( TInt aErrorCode );
       
  1064         
       
  1065         /**
       
  1066          * Completes update life timer request
       
  1067          *          
       
  1068          *
       
  1069          * @param aErrorCode Symbian OS error code
       
  1070          */
       
  1071         void CompleteUpdateLifeTimer( TInt aErrorCode );                
       
  1072 
       
  1073         /*
       
  1074          * Returns true if refresh called (caching initiated from SIM)
       
  1075          *          
       
  1076          *
       
  1077          * @return ETrue if refresh initiated from SIM, otherwise EFalse
       
  1078          */
       
  1079         TBool IsRefreshOngoing();
       
  1080 
       
  1081         /**
       
  1082          * Completes the refresh now -indication, sets refresh flag to ETrue 
       
  1083          * and initiates the SIM file caching
       
  1084          *          
       
  1085          *
       
  1086          * @param aFilesToRefresh SIM file types that need to be refreshed 
       
  1087          */
       
  1088         void CompleteSimRefreshNowL( TUint16 aFilesToRefresh );
       
  1089 
       
  1090         /**
       
  1091          * Starts caching the next SIM file in queue
       
  1092          * const TCacheFileTypes aFileType SIM file type to be refreshed
       
  1093          *          
       
  1094          *
       
  1095          * @return EFalse if no files in queue, otherwise ETrue
       
  1096          */
       
  1097         TBool CacheNextL();
       
  1098 
       
  1099         /**
       
  1100          * Removes SIM file(s) from caching queue and calls complete for 
       
  1101          * RefreshNow if no more files in queue
       
  1102          *          
       
  1103          *
       
  1104          * @param aFileType SIM filetypes to be removed from the queue
       
  1105          * @param aReadError Error value for reading the cache
       
  1106          */
       
  1107         void CompleteCacheSimL( const TUint8 aFileType, 
       
  1108             TInt aReadError );
       
  1109 
       
  1110         /**
       
  1111          * Completes the refresh by notifying server for completion
       
  1112          * TBool aReadError: If error occured when reading files: ETrue, 
       
  1113          * otherwise EFalse
       
  1114          *          
       
  1115          *
       
  1116          * @param aReadError
       
  1117          */
       
  1118         void NotifySimRefreshCompletionL( TBool aReadError );
       
  1119 
       
  1120         /**
       
  1121          * Completes ims authentication request
       
  1122          *          
       
  1123          *
       
  1124          * @param aDataPackage Holds authentication data from sim
       
  1125          * @param aResult Error value
       
  1126          */
       
  1127         void CompleteImsAuthentication( 
       
  1128             CMmDataPackage* aDataPackage,
       
  1129             TInt aResult );
       
  1130             
       
  1131         /**
       
  1132          * Completes the NotifyIndicatorChange if indicator state
       
  1133          * has changed.
       
  1134          *          
       
  1135          *
       
  1136          */
       
  1137         void CompleteNotifyIndicatorChange();
       
  1138 
       
  1139         /**
       
  1140          * Completes GetMailboxNumbers request
       
  1141          *          
       
  1142          *
       
  1143          */
       
  1144         void CompleteGetMailboxNumbers(  
       
  1145             CMmDataPackage* aDataPackage, 
       
  1146             TInt aResult );
       
  1147     
       
  1148 #ifdef TF_LOGGING_ENABLED        
       
  1149         /**
       
  1150          * Overloads original ReqCompleted for logging pourpouses
       
  1151          *          
       
  1152          *
       
  1153          * @param aTsyReqHandle
       
  1154          * @param  aError
       
  1155          */
       
  1156         virtual void ReqCompleted(
       
  1157             const TTsyReqHandle aTsyReqHandle,
       
  1158             const TInt aError );
       
  1159 #endif
       
  1160 
       
  1161         /**
       
  1162          * Get pointer to Net Tsy
       
  1163          *          
       
  1164          *
       
  1165          */
       
  1166         CMmNetTsy* GetNetTsy();
       
  1167 
       
  1168         /**
       
  1169          * Get pointer to Security Tsy
       
  1170          *          
       
  1171          *
       
  1172          */
       
  1173         virtual CMmSecurityTsy* GetSecurityTsy();
       
  1174 
       
  1175         /**
       
  1176          * Get pointer to ONStoreTsy
       
  1177          *          
       
  1178          *
       
  1179          * @return pointer to ONStoreTsy
       
  1180          */
       
  1181         CMmONStoreTsy* GetONStoreTsy();
       
  1182 
       
  1183         /** 
       
  1184          * Get pointer to DTMF Tsy
       
  1185          *          
       
  1186          *
       
  1187          */
       
  1188         virtual CMmDtmfTsy* GetDtmfTsy();
       
  1189 
       
  1190         /** 
       
  1191          * Get pointer to Supplementary Services Tsy
       
  1192          *          
       
  1193          *
       
  1194          */
       
  1195         virtual CMmSupplServTsy* GetSupplServTsy();
       
  1196 
       
  1197         /**
       
  1198          * Returns req handle type
       
  1199          *          
       
  1200          *
       
  1201          * @return ReqHandleType
       
  1202          */
       
  1203         CMmPhoneTsy::TPhoneRequestTypes HandleType();
       
  1204 
       
  1205         /**
       
  1206          * Sets the message manager pointer
       
  1207          *          
       
  1208          *
       
  1209          * @param aMessageManager Message manager
       
  1210          */
       
  1211         void SetMessageManager( 
       
  1212             CMmMessageManagerBase* aMessageManager );
       
  1213         /**
       
  1214          * Completes get call forwarding number request
       
  1215          *          
       
  1216          *
       
  1217          * @param aError error value from 
       
  1218          * @param aPackage includes data needed
       
  1219          */
       
  1220         void CompleteGetCallForwardingNumber( TInt aError, 
       
  1221             const CMmDataPackage* aPackage );
       
  1222 
       
  1223         /**
       
  1224          * Complete enumerate APN entries request
       
  1225          *          
       
  1226          *
       
  1227          * @param aDataPackage Datapackage
       
  1228          * @param aErrorCode Error value
       
  1229          */
       
  1230         void CompleteEnumerateAPNEntries( CMmDataPackage* aDataPackage, 
       
  1231             TInt aErrorCode );
       
  1232         
       
  1233         /**
       
  1234          * Complete Get APN name request
       
  1235          *          
       
  1236          *
       
  1237          * @param aDataPackage Datapackage
       
  1238          * @param aErrorCode Error value
       
  1239          */
       
  1240         void CompleteGetAPNname( CMmDataPackage* aDataPackage, 
       
  1241             TInt aErrorCode );
       
  1242             
       
  1243         /**
       
  1244          * Sets ALS Line service status by sim
       
  1245          *          
       
  1246          *
       
  1247          * @param aState boolean for sim based ALS
       
  1248          */
       
  1249         void SetAlsState( TBool aState );
       
  1250         
       
  1251         /**
       
  1252          * Maps ALS line info value
       
  1253          *          
       
  1254          *
       
  1255          * @param aAlsLineInfo
       
  1256          */        
       
  1257         RMobilePhone::TMobilePhoneALSLine MapMEALSLine( TInt aAlsLineInfo );
       
  1258         
       
  1259         /**
       
  1260          * Resets ME ALS info from CentRep.
       
  1261          *          
       
  1262          *
       
  1263          */
       
  1264         void ResetMEAlsInfo();
       
  1265         
       
  1266         /**
       
  1267          * Returns sim refresh registration status 
       
  1268          *          
       
  1269          *
       
  1270          */    
       
  1271         TBool GetSimRefreshRegister(); 
       
  1272     
       
  1273         /**
       
  1274          * Starts new cache when PB read is called and sim refresh registration 
       
  1275          * is failed 
       
  1276          *          
       
  1277          *
       
  1278          * @param aPhoneBookType phonebook to be cached
       
  1279          * @return error value
       
  1280          */  
       
  1281         TInt StartNewCacheL( TUint8 aPhoneBookType );
       
  1282         
       
  1283         /**
       
  1284          * Returns pointer to public CentRep
       
  1285          *          
       
  1286          *
       
  1287          */
       
  1288         CRepository* GetCfisCenRep();
       
  1289         
       
  1290         /**
       
  1291          * Returns pointer to public CentRep:
       
  1292          *          
       
  1293          *
       
  1294          */
       
  1295         CRepository* GetMwisCenRep();
       
  1296 
       
  1297         /**
       
  1298          * Returns pointer to private CentRep:
       
  1299          *          
       
  1300          *
       
  1301          */
       
  1302         CRepository* GetCfisPRCenRep();
       
  1303 
       
  1304         /**
       
  1305          * Complete Append APN name request
       
  1306          * 
       
  1307          *
       
  1308          * @param aErrorCode Error value
       
  1309          */
       
  1310         void CompleteAppendAPNName( TInt aErrorCode );
       
  1311         
       
  1312         /**
       
  1313          * Complete delete APN entry
       
  1314          * 
       
  1315          *
       
  1316          * @param aErrorCode Error value
       
  1317          */
       
  1318         void CompleteDeleteAPNName( TInt aErrorCode );
       
  1319         
       
  1320         /**
       
  1321          * Complete notification request
       
  1322          *          
       
  1323          *
       
  1324          * @param aErrorCode Error value
       
  1325          */
       
  1326         void CompleteNotifyAPNListChanged( TInt aErrorCode );
       
  1327 
       
  1328         /**
       
  1329          * Complete Set APN service status
       
  1330          * 
       
  1331          *
       
  1332          * @param aErrorCode Error value
       
  1333          */
       
  1334         void CompleteSetAPNControlListServiceStatus( TInt aErrorCode );
       
  1335         
       
  1336         /**
       
  1337          * Complete Get APN service status
       
  1338          * 
       
  1339          *
       
  1340          * @param aDataPackage Datapackage
       
  1341          * @param aErrorCode Error value
       
  1342          */
       
  1343         void CompleteGetAPNControlListServiceStatus( CMmDataPackage* 
       
  1344             aDataPackage, TInt aErrorCode );
       
  1345         
       
  1346         /**
       
  1347          * Complete service status notification
       
  1348          *          
       
  1349          *
       
  1350          * @param aDataPackage Datapackage
       
  1351          * @param aErrorCode Error value
       
  1352          */
       
  1353         void CompleteNotifyAPNControlListServiceStatusChange( 
       
  1354             CMmDataPackage* aDataPackage, TInt aErrorCode );
       
  1355             
       
  1356         /**
       
  1357          * Returns current nr of active calls
       
  1358          *
       
  1359          */
       
  1360         TInt NumberOfActiveCalls() const { return iAmountOfActiveCalls; }
       
  1361         
       
  1362         /**
       
  1363          * Complete call duration change notification
       
  1364          *          
       
  1365          *
       
  1366          */
       
  1367         void CompleteNotifyCallDurationChange();                    
       
  1368             
       
  1369         /**
       
  1370          * SetAlsQueryInBoot request
       
  1371          *
       
  1372          * @param aInBoot bootupflag if als is asked during boot
       
  1373          */
       
  1374         void SetAlsQueryInBoot( TBool aInBoot );
       
  1375             
       
  1376         /**
       
  1377          * GetAlsQueryInBoot request
       
  1378          *
       
  1379          * @return TBool
       
  1380          */
       
  1381         TBool GetAlsQueryInBoot();
       
  1382         
       
  1383         /**
       
  1384          * If HomeZoneParams has been asked
       
  1385          *
       
  1386          * @return TBool
       
  1387          */
       
  1388 		TBool GetHomeZoneParamsChecked();
       
  1389 		
       
  1390 		/**
       
  1391          * Set HomeZoneParams status
       
  1392          *
       
  1393          * @param aHomeZoneChecked
       
  1394          */
       
  1395 		void SetHomeZoneParamsChecked( TBool aHomeZoneChecked );      
       
  1396         
       
  1397 		/**
       
  1398 	     * This method set the initialization status of the phonebook
       
  1399 	     *
       
  1400 		 * @param aIsInitializationActive is initialization active or not
       
  1401 		 */
       
  1402 		void SetPBInitActiveStatus( TBool aIsInitializationActive );
       
  1403 		
       
  1404 		/**
       
  1405 		 * This method returns the initialization status of the phonebook
       
  1406 		 *
       
  1407 		 * @return Phonebook init status
       
  1408 		 */
       
  1409 		 TBool IsPBInitActive();
       
  1410         
       
  1411 		
       
  1412         /**
       
  1413 		 * Complete TerminateAllCalls request
       
  1414 		 * 
       
  1415 		 * @param aErrorCode The result of the request
       
  1416 		 */
       
  1417         void CompleteTerminateAllCallsReq(TInt aErrorCode);
       
  1418         
       
  1419         /**
       
  1420         * Notify change of battery info
       
  1421         *          
       
  1422         * @param aErrorCode error code
       
  1423         * @param aBatteryData data structure used to retreive data from a call
       
  1424         *  to GetBatteryInfo
       
  1425         */
       
  1426         void NotifyBatteryInfo( TInt aErrorCode, 
       
  1427             CHWRMPower::TBatteryConsumptionData aBatteryData );
       
  1428         
       
  1429         /**
       
  1430         * Notify change of charging status
       
  1431         *          
       
  1432         * @param aErrorCode error code
       
  1433         * @param aBatteryInfo package containing power and battery status
       
  1434         */
       
  1435         void NotifyChargingStatus( TInt aErrorCode, 
       
  1436             RMobilePhone::TMobilePhoneBatteryInfoV1 aBatteryInfo );
       
  1437 #ifdef USING_CTSY_DISPATCHER
       
  1438         /**
       
  1439          * Sets iPhoneIdentity
       
  1440          * This is for when the LTSY can return the entire TMobilePhoneIdentityV1           
       
  1441          *
       
  1442          * @param aPhoneId The phone identity
       
  1443          * @param aError error code
       
  1444          */
       
  1445         virtual void CompleteGetPhoneId(
       
  1446         	const RMobilePhone::TMobilePhoneIdentityV1& aPhoneId,
       
  1447             TInt aError );
       
  1448 #endif //USING_CTSY_DISPATCHER
       
  1449         
       
  1450         /**
       
  1451          * This method returns whether SIM is ready or not.
       
  1452          *
       
  1453          * @return SIM status
       
  1454          */
       
  1455         TBool IsSIMReady();
       
  1456 	
       
  1457         /*
       
  1458 		 * This method saves FDN details in case of FDN Phonebook not created
       
  1459          *
       
  1460          * @since S60 v3.2
       
  1461          * @param  aErrorCode Error value
       
  1462          * @param  aDataPackage DataPackage
       
  1463          */
       
  1464         void SaveFdnInfoDetails(TInt aErrorCode, CMmDataPackage* aDataPackage );
       
  1465 
       
  1466     private:
       
  1467     
       
  1468         /**
       
  1469          * C++ default constructor.
       
  1470          */
       
  1471         CMmPhoneTsy();
       
  1472 
       
  1473         /**
       
  1474          * By default Symbian 2nd phase constructor is private.
       
  1475          */
       
  1476         void ConstructL();
       
  1477 
       
  1478         /**
       
  1479          * Initialises transaction handler, TSY req handle store, 
       
  1480          * and object lists
       
  1481          *          
       
  1482          *
       
  1483          */
       
  1484         void InitStoresAndListsL();
       
  1485 
       
  1486         /**
       
  1487          * Initialises extension modules
       
  1488          *          
       
  1489          *
       
  1490          */
       
  1491         void InitExtensionModulesL();
       
  1492 
       
  1493         /**
       
  1494          * Initialise miscellaneous internal attributes
       
  1495          *          
       
  1496          *
       
  1497          */
       
  1498         void InitInternalAttributes();
       
  1499 
       
  1500         /**
       
  1501          * Handles extended client requests. Uses TRAP to ensure functioning on
       
  1502          * memory allocation failure
       
  1503          *          
       
  1504          *
       
  1505          * @param aTsyReqHandle TSY request handle
       
  1506          * @param aIpc request IPC number
       
  1507          * @param aPackage packaged request parameters
       
  1508          * @return result of the request
       
  1509          */
       
  1510         TInt DoExtFuncL( const TTsyReqHandle aTsyReqHandle, 
       
  1511             const TInt aIpc, 
       
  1512             const TDataPackage& aPackage );
       
  1513 
       
  1514         /**
       
  1515          * Handles cancel methods that cause message sending to DOS.
       
  1516          *          
       
  1517          *
       
  1518          * @param aIpc request IPC number
       
  1519          * @param aTsyReqHandle TSY request handle
       
  1520          * @return result of the request
       
  1521          */
       
  1522         TInt CancelToPhonetL( const TInt aIpc, 
       
  1523                 const TTsyReqHandle aTsyReqHandle );
       
  1524 
       
  1525         /**
       
  1526          * Traped Initialisation method
       
  1527          *          
       
  1528          *
       
  1529          */
       
  1530         void InitL();
       
  1531 
       
  1532         /**
       
  1533          * Get ICC Access Capabilities
       
  1534          *          
       
  1535          *
       
  1536          * @param aTsyReqHandle
       
  1537          * @param aCaps
       
  1538          * @return error value
       
  1539          */
       
  1540         TInt GetIccAccessCaps( const TTsyReqHandle aTsyReqHandle, 
       
  1541             TUint32* aCaps );
       
  1542 
       
  1543         /**
       
  1544          * Notify Change of ICC Access Caps
       
  1545          *          
       
  1546          *
       
  1547          * @param aCaps
       
  1548          * @return error value
       
  1549          */
       
  1550         TInt NotifyIccAccessCapsChange( TUint32* aCaps );
       
  1551         
       
  1552         /**
       
  1553          * Get Service Table and check validity of client parameters
       
  1554          *          
       
  1555          *
       
  1556          * @param aTsyReqHandle TSY request handle
       
  1557          * @param aTable Service Table specifier
       
  1558          * @param aTableData Service Table file contents
       
  1559          * @return KErrNone or system wide error
       
  1560          */
       
  1561         TInt GetServiceTableCheckParametersL( 
       
  1562             const TTsyReqHandle aTsyReqHandle, 
       
  1563             RMobilePhone::TMobilePhoneServiceTable* aTable,
       
  1564             TDes8* aTableData );        
       
  1565 
       
  1566         /**
       
  1567          * Get Service Table
       
  1568          *          
       
  1569          *
       
  1570          * @param aTsyReqHandle TSY request handle
       
  1571          * @param aTable Service Table specifier
       
  1572          * @param aTableData Service Table file contents
       
  1573          * @return status
       
  1574          */
       
  1575         TInt GetServiceTableL( const TTsyReqHandle aTsyReqHandle, 
       
  1576             RMobilePhone::TMobilePhoneServiceTable* aTable,
       
  1577             RMobilePhone::TMobilePhoneServiceTableV1* aTableData );
       
  1578 
       
  1579         /**
       
  1580          * This function cancels GetServiceTable request
       
  1581          *          
       
  1582          *
       
  1583          * @param aTsyReqHandle TSY request handle
       
  1584          * @return status
       
  1585          */
       
  1586         TInt GetServiceTableCancel ( const TTsyReqHandle aTsyReqHandle );
       
  1587         
       
  1588         /**
       
  1589          * Get Phone Store Info
       
  1590          *          
       
  1591          *
       
  1592          * @param aInfo pointer to ETel server phone store info data
       
  1593          * @param aStoreName name of the store
       
  1594          * @return error value
       
  1595          */
       
  1596         TInt GetPhoneStoreInfoL( TDes8* aInfo,
       
  1597             const RMobilePhone::TMobileName* aStoreName );
       
  1598 
       
  1599         /**
       
  1600          * This function cancels GetPhoneStoreInfo request
       
  1601          *          
       
  1602          *
       
  1603          * @param aTsyReqHandle TSY request handle
       
  1604          * @return status
       
  1605          */
       
  1606         TInt GetPhoneStoreInfoCancel( const TTsyReqHandle aTsyReqHandle );
       
  1607 
       
  1608         /**
       
  1609          * This function returns phone ID.
       
  1610          *          
       
  1611          *
       
  1612          * @param aTsyReqHandle request handle
       
  1613          * @param aId aId pointer
       
  1614          * @return KErrNone
       
  1615          */
       
  1616         TInt GetPhoneIdL( const TTsyReqHandle aTsyReqHandle, 
       
  1617             RMobilePhone::TMobilePhoneIdentityV1* aId );
       
  1618 
       
  1619         /**
       
  1620          * This is a helper function for GetPhoneIdL.
       
  1621          *          
       
  1622          *
       
  1623          * @param aTsyReqHandle request handle
       
  1624          * @param aId aId pointer
       
  1625          */        
       
  1626         void DoGetPhoneIdL(const TTsyReqHandle aTsyReqHandle,
       
  1627         		RMobilePhone::TMobilePhoneIdentityV1* aId);
       
  1628 
       
  1629         /**
       
  1630          * This function returns subscriber ID.
       
  1631          *          
       
  1632          *
       
  1633          * @param aTsyReqHandle request handle
       
  1634          * @param aId aId pointer
       
  1635          * @return KErrNone
       
  1636          */
       
  1637         TInt GetSubscriberIdL( const TTsyReqHandle aTsyReqHandle, 
       
  1638             RMobilePhone::TMobilePhoneSubscriberId* aId );
       
  1639 
       
  1640         /**
       
  1641          * This function cancels GetSubscriberId request
       
  1642          *          
       
  1643          * 
       
  1644          * @param aTsyReqHandle request handle
       
  1645          * @return KErrNone
       
  1646          */
       
  1647         TInt GetSubscriberIdCancel( const TTsyReqHandle aTsyReqHandle );
       
  1648 
       
  1649         /**
       
  1650          * This request function returns Phone Indicator state to the client.
       
  1651          *          
       
  1652          *
       
  1653          * @param aTsyReqHandle request handle
       
  1654          * @param aIndicators indicator pointer
       
  1655          * @return KErrNone, or KErrGeneral, if the input pointer is NULL
       
  1656          */
       
  1657         TInt GetIndicators( const TTsyReqHandle aTsyReqHandle,    
       
  1658              TUint32* aIndicators);
       
  1659         
       
  1660         /**
       
  1661          * Returns multimode capabilities
       
  1662          *          
       
  1663          *
       
  1664          * @param aTsyReqHandle TSY request handle
       
  1665          * @param aCaps multimode capabilities
       
  1666          * @return Return value to the ETel Server
       
  1667          */
       
  1668         TInt GetMultimodeCaps( const TTsyReqHandle aTsyReqHandle, 
       
  1669             TUint32* aCaps );
       
  1670 
       
  1671         /**
       
  1672          * This function returns signal capabilities
       
  1673          *          
       
  1674          *
       
  1675          * @param aTsyReqHandle Tsy request handle
       
  1676          * @param aCaps Capabilities
       
  1677          * @return KErrNone
       
  1678          */
       
  1679         TInt GetSignalCaps( const TTsyReqHandle aTsyReqHandle, 
       
  1680             TUint32* aCaps );
       
  1681 
       
  1682         /**
       
  1683          * This function returns identity capabilities
       
  1684          *          
       
  1685          *
       
  1686          * @param aTsyReqHandle request handle
       
  1687          * @param TaCaps pointer to aCaps
       
  1688          * @return KErrNone
       
  1689          */
       
  1690         TInt GetIdentityCaps( const TTsyReqHandle aTsyReqHandle, 
       
  1691             TUint32* aCaps );
       
  1692 
       
  1693         /**
       
  1694          * This function returns network capabilities
       
  1695          *          
       
  1696          *
       
  1697          * @param aTsyReqHandle Request handle
       
  1698          * @param aCaps Capabilities
       
  1699          * @return KErrNone
       
  1700          */
       
  1701         TInt GetNetworkCaps( const TTsyReqHandle aTsyReqHandle, 
       
  1702             TUint32* aCaps );
       
  1703 
       
  1704         /**
       
  1705          * This function returns phone indicator capabilities
       
  1706          *          
       
  1707          *
       
  1708          * @param aTsyReqHandle Request handle
       
  1709          * @param aActCaps: Action Capabilities (get, notify)
       
  1710          * using a RMobilePhone::TMobilePhoneIndicatorCaps -type bitmasks
       
  1711          * @param aIndCaps: the kind of indicators can be given
       
  1712          * using a RMobilePhone::TMobilePhoneIndicators -type bitmasks
       
  1713          * @return KErrNone, or KErrGeneral if any of the input 
       
  1714          *              pointers are NULL
       
  1715          */
       
  1716         TInt GetIndicatorCaps( const TTsyReqHandle aTsyReqHandle,    
       
  1717             TUint32* aActCaps,                        
       
  1718             TUint32* aIndCaps );
       
  1719         
       
  1720         /**
       
  1721          * Get Customer Service Profile
       
  1722          *          
       
  1723          *
       
  1724          * @param aTsyReqHandle Tsy request handle
       
  1725          * @param aCspFile Customer Service Profile file
       
  1726          * @return status
       
  1727          */
       
  1728         TInt GetCustomerServiceProfileL( const TTsyReqHandle aTsyReqHandle, 
       
  1729             TDes8* aCspFile );
       
  1730  
       
  1731         /**
       
  1732          * This function cancels an outstanding get customer service profile
       
  1733          * request
       
  1734          *         
       
  1735          * @param aTsyReqHandle Request handle
       
  1736          * @return KErrNone
       
  1737          */
       
  1738         TInt GetCustomerServiceProfileCancel(
       
  1739                 const TTsyReqHandle aTsyReqHandle );
       
  1740         
       
  1741         /**
       
  1742          * This function returns battery capabilities.
       
  1743          *          
       
  1744          *
       
  1745          * @param aTsyReqHandle request handle
       
  1746          * @param aCaps pointer to aCaps
       
  1747          * @return KErrNone
       
  1748          */
       
  1749         TInt GetBatteryCaps( 
       
  1750             const TTsyReqHandle aTsyReqHandle, 
       
  1751             TUint32* aCaps );
       
  1752 
       
  1753         /**
       
  1754          * This function returns battery informations.
       
  1755          *          
       
  1756          *
       
  1757          * @param aTsyReqHandle request handle
       
  1758          * @param aInfo aInfo pointer
       
  1759          * @return KErrNone
       
  1760          */
       
  1761         TInt GetBatteryInfoL( 
       
  1762             const TTsyReqHandle aTsyReqHandle, 
       
  1763             RMobilePhone::TMobilePhoneBatteryInfoV1* aInfo );
       
  1764 
       
  1765         /**
       
  1766          * This function is used to request battery info change notifications.
       
  1767          *          
       
  1768          *
       
  1769          * @param aInfo battery info
       
  1770          * @return KErrNone
       
  1771          */
       
  1772         TInt NotifyBatteryInfoChange( 
       
  1773             RMobilePhone::TMobilePhoneBatteryInfoV1* aInfo );
       
  1774 
       
  1775         /**
       
  1776          * This function cancels an outstanding battery info change notification
       
  1777          * request
       
  1778          *          
       
  1779          *
       
  1780          * @param aTsyReqHandle Request handle
       
  1781          * @return KErrNone
       
  1782          */
       
  1783         TInt NotifyBatteryInfoChangeCancel( 
       
  1784             const TTsyReqHandle aTsyReqHandle );
       
  1785 
       
  1786 
       
  1787         /**
       
  1788          * This function is used to request indicator change notifications.
       
  1789          *          
       
  1790          *
       
  1791          * @param aIndicatorState indicator state
       
  1792          * @return KErrNone
       
  1793          */
       
  1794         TInt NotifyIndicatorChange( TUint32* aIndicatorState );
       
  1795 
       
  1796         /**
       
  1797          * Cancels NotifyIndicatorChange
       
  1798          *          
       
  1799          *
       
  1800          * @param aTsyReqHandle TSY request handle
       
  1801          * @return result of the request
       
  1802          *
       
  1803          */
       
  1804         TInt NotifyIndicatorChangeCancel( const TTsyReqHandle aTsyReqHandle );
       
  1805 
       
  1806         /**
       
  1807          * Get service provider name from Sim
       
  1808          *          
       
  1809          *
       
  1810          * @param aTsyReqHandle Tsy request handle
       
  1811          * @param aName Service provider name info
       
  1812          * @return KErrNone or system wide error code
       
  1813          */
       
  1814         TInt GetServiceProviderNameL( const TTsyReqHandle aTsyReqHandle, 
       
  1815             TDes8* aName );
       
  1816 
       
  1817         /** This function cancels the service provider name retrieving.
       
  1818          *        
       
  1819          *
       
  1820          * @param aTsyReqHandle request handle
       
  1821          * @return KErrNone
       
  1822          */
       
  1823         TInt GetServiceProviderNameCancel( const TTsyReqHandle aTsyReqHandle );
       
  1824 
       
  1825         /**
       
  1826          * This method allows a client to find out which voice line 
       
  1827          * is currently selected as the active ALS line for outgoing 
       
  1828          * voice calls.
       
  1829          *          
       
  1830          * 
       
  1831          * @param aALSLine Selected line
       
  1832          * @return KErrNone
       
  1833          */
       
  1834         TInt GetALSLineL( const TTsyReqHandle aTsyReqHandle,
       
  1835             RMobilePhone::TMobilePhoneALSLine* aALSLine );
       
  1836         
       
  1837         /**
       
  1838          * This method allows a client to set which voice line is currently 
       
  1839          * selected as the active ALS line for outgoing voice calls
       
  1840          *          
       
  1841          *
       
  1842          * @param aALSLine line selection
       
  1843          * @return KErrNone
       
  1844          */
       
  1845         TInt SetALSLineL( const TTsyReqHandle aTsyReqHandle, 
       
  1846             RMobilePhone::TMobilePhoneALSLine* aALSLine );
       
  1847         
       
  1848         /**
       
  1849          * This method allows a client to be notified if the currently selected 
       
  1850          * ALS line changes
       
  1851          *          
       
  1852          *
       
  1853          * @param aALSLine new active line 
       
  1854          * @return KErrNone
       
  1855          */
       
  1856         TInt NotifyALSLineChange( 
       
  1857             RMobilePhone::TMobilePhoneALSLine* aALSLine );
       
  1858 
       
  1859         /**
       
  1860          * This method cancels order to notify if ALS line changes
       
  1861          *          
       
  1862          *
       
  1863          * @param aTsyReqHandle request handle
       
  1864          * @return KErrNone
       
  1865          */
       
  1866         TInt NotifyALSLineChangeCancel( const TTsyReqHandle aTsyReqHandle );
       
  1867 
       
  1868         /**
       
  1869          * This method retrieves the current status of the Fixed Dialling 
       
  1870          * Numbers service
       
  1871          *          
       
  1872          *
       
  1873          * @param aTsyReqHandle request handle
       
  1874          * @param aStatus current status
       
  1875          * @return KErrNone
       
  1876          */
       
  1877         TInt GetFdnStatusL( const TTsyReqHandle aTsyReqHandle,
       
  1878             RMobilePhone::TMobilePhoneFdnStatus* aFdnStatus );
       
  1879         
       
  1880         /**
       
  1881          * This method cancels Fixed Dialling Numbers service request
       
  1882          *
       
  1883          *
       
  1884          * @param aTsyReqHandle request handle
       
  1885          * @return KErrNone
       
  1886          */
       
  1887         TInt GetFdnStatusCancel( const TTsyReqHandle aTsyReqHandle );
       
  1888 
       
  1889         /**
       
  1890          * This method activates (ON) or deactivates (OFF) the Fixed 
       
  1891          * Dialling Numbers (FDN) service. 
       
  1892          *          
       
  1893          *
       
  1894          * @param aTsyReqHandle request handle
       
  1895          * @param aFdnsetting new setting
       
  1896          * @return KErrNone
       
  1897          */
       
  1898         TInt SetFdnSettingL( const TTsyReqHandle aTsyReqHandle,
       
  1899             const TDataPackage& aPackage );
       
  1900 
       
  1901         /**
       
  1902          * This request allows a client to be notified when the status of the 
       
  1903          * FDN service has changed
       
  1904          *          
       
  1905          *
       
  1906          * @param aStatus status
       
  1907          * @return KErrNone
       
  1908          */
       
  1909         TInt NotifyFdnStatusChange( 
       
  1910             RMobilePhone::TMobilePhoneFdnStatus* aStatus );
       
  1911 
       
  1912         /**
       
  1913          * This request cancels order to notify if status changes
       
  1914          *          
       
  1915          *
       
  1916          * @param aTsyReqHandle request handle
       
  1917          * @return KErrNone
       
  1918          */
       
  1919         TInt NotifyFdnStatusChangeCancel( const TTsyReqHandle aTsyReqHandle );
       
  1920 
       
  1921         /**
       
  1922          * Returns current indicator state according to batteryInfo,
       
  1923          * networkStatus and call state
       
  1924          *          
       
  1925          *
       
  1926          * @return bit mask of enabled features using
       
  1927          * RMobilePhone::TMobilePhoneIndicators
       
  1928          */
       
  1929         TUint32 GetIndicatorState();
       
  1930 
       
  1931         /**
       
  1932          * Get current subscriber ID (IMSI) for TSY internal use
       
  1933          *          
       
  1934          *
       
  1935          */
       
  1936         void GetSubscriberIdForTSYL();
       
  1937 
       
  1938 #ifdef REQHANDLE_TIMER
       
  1939         /**
       
  1940          * Chooses the type of response, automatic or common
       
  1941          *          
       
  1942          *
       
  1943          * @param aReqHandleType req handle type.
       
  1944          * @param aTsyReqHandle: req handle to be stored.
       
  1945          */
       
  1946         void SetTypeOfResponse( const TInt aReqHandleType, 
       
  1947             const TTsyReqHandle aTsyReqHandle ); 
       
  1948         
       
  1949 #endif
       
  1950  
       
  1951         /**
       
  1952          * Checks wether or not a ETel request can be performed
       
  1953          * while offline mode is enabled
       
  1954          *          
       
  1955          *
       
  1956          * @param aIpc Ipc number of the request
       
  1957          * @return Boolean indicating if request is possible in offline
       
  1958          */
       
  1959         TBool IsRequestPossibleInOffline( TInt aIpc );
       
  1960         
       
  1961         /**
       
  1962          * Authenticates with data provided by client
       
  1963          * @param aAuthenticationData Pointer to IMS authentication data.
       
  1964          * @return TInt KErrNone
       
  1965          */
       
  1966         TInt ImsAuthenticationL( TDes8* aAuthenticationData );
       
  1967 
       
  1968         /**
       
  1969          * Cancels sim authenticaiton request
       
  1970          *          
       
  1971          *
       
  1972          * @return KErrNone
       
  1973          */
       
  1974         TInt ImsAuthenticationCancel();
       
  1975         
       
  1976         /**
       
  1977          * Caches Service Tables
       
  1978          *          
       
  1979          *
       
  1980          * @return KErrNone
       
  1981          */
       
  1982         void CacheServiceTablesL();
       
  1983         
       
  1984         /**
       
  1985          * Completes caching of Service Tables
       
  1986          *          
       
  1987          *
       
  1988          * @return TInt KErrNone
       
  1989          */
       
  1990         void CompleteCacheServiceTablesL(const TInt aError);
       
  1991         
       
  1992         /**
       
  1993          * Requests mailbox numbers identifier information
       
  1994          * @param aMailBox mailbox data.
       
  1995          *          
       
  1996          *
       
  1997          * @return KErrNone
       
  1998          */
       
  1999         TInt GetMailboxNumbersL( TDes8* aMailBox );
       
  2000         
       
  2001         /**
       
  2002          * Cancels get mailbox numbers  request
       
  2003          *          
       
  2004          *
       
  2005          * @return KErrNone
       
  2006          */
       
  2007         TInt GetMailboxNumbersCancel();
       
  2008             
       
  2009         /**
       
  2010          * Enumerates number of APN entries in ACL
       
  2011          *          
       
  2012          *
       
  2013          * @param aTsyReqHandle Request Handle
       
  2014          * @param aIndex Pointer to index
       
  2015          * @return Error value
       
  2016          */
       
  2017         TInt EnumerateAPNEntriesL( const TTsyReqHandle aTsyReqHandle, 
       
  2018             TUint32* aIndex );
       
  2019         
       
  2020         /**
       
  2021          * Cancel enumerate APN entries request
       
  2022          *          
       
  2023          *
       
  2024          * @return Error value
       
  2025          */
       
  2026         TInt EnumerateAPNEntriesCancel();
       
  2027         
       
  2028         /**
       
  2029          * Get APN name
       
  2030          *          
       
  2031          *
       
  2032          * @param aTsyReqHandle Request handle
       
  2033          * @param aIndex Index of requested APN
       
  2034          * @param aAPN APN name
       
  2035          * @return Error value
       
  2036          */
       
  2037         TInt GetAPNnameL( const TTsyReqHandle aTsyReqHandle, TUint32* aIndex, 
       
  2038             TDes8* aAPN );
       
  2039         
       
  2040         /**
       
  2041          * Cancel get APN name request
       
  2042          *          
       
  2043          *
       
  2044          * @return Error value
       
  2045          */
       
  2046         TInt GetAPNnameCancel();
       
  2047 
       
  2048         /**
       
  2049          * Append an entry to the access point name (APN) control list
       
  2050          * 
       
  2051          *
       
  2052          * @param aAPNEntry APN Entry
       
  2053          * @return Error value
       
  2054          */
       
  2055         TInt AppendAPNNameL( RMobilePhone::TAPNEntryV3* aAPNEntry );
       
  2056         
       
  2057         /**
       
  2058          * Cancel AppendAPNName
       
  2059          * 
       
  2060          *
       
  2061          * @return KErrNone
       
  2062          */
       
  2063         TInt AppendAPNNameCancel();
       
  2064 
       
  2065         /**
       
  2066          * Delete an entry from the access point name (APN) control list
       
  2067          * 
       
  2068          *
       
  2069          * @param aTsyReqHandle TSY req handle
       
  2070          * @param aIndex Deleted index
       
  2071          * @return Error value
       
  2072          */
       
  2073         TInt DeleteAPNNameL( const TTsyReqHandle aTsyReqHandle, 
       
  2074             TUint32* aIndex );
       
  2075         
       
  2076         /**
       
  2077          * Cancel DeleteAPNName
       
  2078          * 
       
  2079          *
       
  2080          * @return KErrNone
       
  2081          */
       
  2082         TInt DeleteAPNNameCancel();
       
  2083         
       
  2084         /**
       
  2085          * This function is used to request to receive notification of when 
       
  2086          * the APN control list changes.
       
  2087          *          
       
  2088          *
       
  2089          * @return KErrNone
       
  2090          */
       
  2091         TInt NotifyAPNListChanged();
       
  2092 
       
  2093         /**
       
  2094          * This function cancels an outstanding access point name (APN) 
       
  2095          * control list change notification request.
       
  2096          *          
       
  2097          *
       
  2098          * @return KErrNone
       
  2099          */
       
  2100         TInt NotifyAPNListChangedCancel();
       
  2101 
       
  2102         /**
       
  2103          * Enabling and disabling the access point name (APN) 
       
  2104          * control list service
       
  2105          * 
       
  2106          * @param aTsyReqHandle TSY req handle
       
  2107          * @param aAPNControlListServiceStatus ACL status
       
  2108          * @return Error value
       
  2109          */
       
  2110         TInt SetAPNControlListServiceStatusL( 
       
  2111             const TTsyReqHandle aTsyReqHandle, 
       
  2112             RMobilePhone::TAPNControlListServiceStatus* 
       
  2113             aAPNControlListServiceStatus );
       
  2114         
       
  2115         /**
       
  2116          * Cancel the request to set ACL status
       
  2117          * 
       
  2118          *
       
  2119          * @return KErrNone
       
  2120          */
       
  2121         TInt SetAPNControlListServiceStatusCancel();
       
  2122         
       
  2123         /**
       
  2124          * Get the status of the access point name (APN) control list service
       
  2125          * 
       
  2126          *
       
  2127          * @param aTsyReqHandle TSY req handle
       
  2128          * @param aAPNControlListServiceStatus ACL status
       
  2129          * @return Error value
       
  2130          */
       
  2131         TInt GetAPNControlListServiceStatusL( 
       
  2132             const TTsyReqHandle aTsyReqHandle, 
       
  2133             RMobilePhone::TAPNControlListServiceStatus* 
       
  2134             aAPNControlListServiceStatus );
       
  2135         
       
  2136         /**
       
  2137          * Cancel the request to get ACL status
       
  2138          * 
       
  2139          *
       
  2140          * @return KErrNone
       
  2141          */
       
  2142         TInt GetAPNControlListServiceStatusCancel();
       
  2143 
       
  2144         /**
       
  2145          * This function is used to request to receive notification of when 
       
  2146          * the status of the APN control list service changes.
       
  2147          *          
       
  2148          *
       
  2149          * @param aAPNControlListServiceStatus
       
  2150          * @return KErrNone
       
  2151          */
       
  2152         TInt NotifyAPNControlListServiceStatusChange( 
       
  2153             RMobilePhone::TAPNControlListServiceStatus* 
       
  2154             aAPNControlListServiceStatus );
       
  2155 
       
  2156         /**
       
  2157          * This function cancels an outstanding access point name (APN) 
       
  2158          * control list service status change notification request.
       
  2159          *          
       
  2160          *
       
  2161          * @return KErrNone
       
  2162          */
       
  2163         TInt NotifyAPNControlListServiceStatusChangeCancel();
       
  2164         
       
  2165         /**
       
  2166           * Terminate all calls simultaneously
       
  2167           * 
       
  2168           * @param aTsyReqHandle TSY req handle
       
  2169           * @return Error value
       
  2170           */
       
  2171         TInt TerminateAllCallsL(const TTsyReqHandle aTsyReqHandle);
       
  2172 
       
  2173         /*
       
  2174          * This function return availability of Hareware Resource Manager in the current ROM
       
  2175          * 
       
  2176          * @return TTrue indicate HWRM is available. TFalse indicate it is unavailable
       
  2177          */
       
  2178         TBool IsHWRMSupported();
       
  2179 
       
  2180 #ifdef REQHANDLE_TIMER
       
  2181         /**
       
  2182          * Sets the security code when the request completes due to timer expiration
       
  2183          * and then it calls the completion function to handle the timeout event.         
       
  2184          *
       
  2185          * @param aReqHandleType req handle type.
       
  2186          * @param aError: error code.
       
  2187          */
       
  2188         void TimeoutGetSecurityCodeInfo(const TInt aReqHandleType, const TInt aError);
       
  2189 #endif
       
  2190 
       
  2191     private:    // Data
       
  2192         
       
  2193         /**
       
  2194          * Property for call forwarding number
       
  2195          */          
       
  2196         RProperty iEmergencyCallInfoProperty;
       
  2197     
       
  2198         /**
       
  2199          * Buffer for call forwarding number
       
  2200          */             
       
  2201         TBuf<40> iCallForwardingNumber;
       
  2202 
       
  2203         /**
       
  2204          * A pointer to the Phone factory
       
  2205          * Own.
       
  2206          */                  
       
  2207         CMmPhoneFactoryTsy* iMmPhoneFactory;
       
  2208 
       
  2209         /**
       
  2210          * A pointer to the active phone extension
       
  2211          * Own.
       
  2212          */                  
       
  2213         CMmPhoneExtInterface* iMmPhoneExtInterface;
       
  2214 
       
  2215         /**
       
  2216          * A pointer to the call list
       
  2217          * Own.
       
  2218          */                  
       
  2219         CMmCallList* iCallList;
       
  2220 
       
  2221         /** 
       
  2222          * A pointer to the line list
       
  2223          * Own         
       
  2224          */         
       
  2225         CMmLineList* iLineList;
       
  2226 
       
  2227         /**
       
  2228          * A pointer to the phonebook list
       
  2229          * own.
       
  2230          */                   
       
  2231         CMmPBList* iPBList;
       
  2232 
       
  2233         /**
       
  2234          * A pointer to the conference call object'
       
  2235          */                  
       
  2236         CMmConferenceCallTsy* iMmConferenceCall; 
       
  2237         
       
  2238         /**
       
  2239          * A pointer to the SAT object       
       
  2240          */                  
       
  2241         CTsySatMessagingBase* iTsySatMessaging;
       
  2242 
       
  2243         /**
       
  2244          * A pointer to the USSD object         
       
  2245          */                  
       
  2246         CMmUssdTsy* iMmUssdTsy;
       
  2247 
       
  2248         /** 
       
  2249          * A pointer to the onstore object
       
  2250          * Own.         
       
  2251          */                  
       
  2252         CMmONStoreTsy* iMmONStoreTsy;
       
  2253 
       
  2254         /**
       
  2255          * A pointer to the enstore object
       
  2256          * Own.         
       
  2257          */                  
       
  2258         CMmENStoreTsy* iMmENStoreTsy;
       
  2259 
       
  2260         /**
       
  2261          * A pointer to the phonebookstore object
       
  2262          * Own.         
       
  2263          */                  
       
  2264         CMmPhoneBookStoreTsy* iMmPhoneBookStoreTsy;
       
  2265 
       
  2266         /**
       
  2267          * A pointer to the Custom TSY                 
       
  2268          */         
       
  2269         CMmCustomTsy* iMmCustomTsy;
       
  2270 
       
  2271         /** 
       
  2272          * A pointer to the multimode messaging object
       
  2273          */         
       
  2274         CMmSmsTsy* iMmSmsTsy;
       
  2275 
       
  2276         /**
       
  2277          * a pointer to the Packet Data object
       
  2278          */         
       
  2279         CMmPacketServiceTsy* iMmPacketServiceTsy;
       
  2280 
       
  2281         /**
       
  2282          * Transaction id
       
  2283          */         
       
  2284         TUint8 iTransId;
       
  2285 
       
  2286         /**
       
  2287          * Phone capabilities
       
  2288          */         
       
  2289         RPhone::TCaps iPhoneCaps;
       
  2290 
       
  2291         /**
       
  2292          * Phone's modem status
       
  2293          */         
       
  2294         RPhone::TStatus iPhoneStatus;
       
  2295 
       
  2296         /** 
       
  2297          * Phone version information
       
  2298          */         
       
  2299         RMobilePhone::TMobilePhoneIdentityV1 iPhoneIdentity;
       
  2300         
       
  2301         /** 
       
  2302          * Phone version information
       
  2303          */
       
  2304         RMobilePhone::TMobilePhoneIdentityV1* iRetPhoneIdentity;
       
  2305 
       
  2306         /**
       
  2307          * Subscriber ID (IMSI)
       
  2308          */         
       
  2309         RMobilePhone::TMobilePhoneSubscriberId iSubscriberId;
       
  2310 
       
  2311         /**
       
  2312          * Pointers to client address space
       
  2313          */         
       
  2314         RPhone::TCaps* iRetCaps;
       
  2315 
       
  2316         /*
       
  2317          * Pointer to client side for modem detection changes
       
  2318          */         
       
  2319         RPhone::TModemDetection* iRetModemDetection;
       
  2320 
       
  2321         /**
       
  2322          * Flag for refresh; set to true when "refresh now" -indication 
       
  2323          * received and to false when all registered files cached
       
  2324          */         
       
  2325         TBool iRefreshOngoing;
       
  2326 
       
  2327         /**
       
  2328          * For keeping list of SIM files left to be cached
       
  2329          */         
       
  2330         TUint16 iSimCacheQueue;        
       
  2331 
       
  2332         /** 
       
  2333          * notify fixed dialing number status
       
  2334          */         
       
  2335         RMobilePhone::TMobilePhoneFdnStatus* iRetNotifyFdnStatus;
       
  2336 
       
  2337         /**
       
  2338          * notify als line
       
  2339          */         
       
  2340         RMobilePhone::TMobilePhoneALSLine* iRetNotifyALSLine;
       
  2341 
       
  2342         /**
       
  2343          * ICC capabolities
       
  2344          */         
       
  2345         TUint32* iICCCaps;
       
  2346 
       
  2347         /**
       
  2348          * Battery info
       
  2349          */         
       
  2350         RMobilePhone::TMobilePhoneBatteryInfoV1 iBatteryInfo;
       
  2351         
       
  2352         /**
       
  2353          * Battery info
       
  2354          */
       
  2355         RMobilePhone::TMobilePhoneBatteryInfoV1* iRetBatteryInfo;
       
  2356 
       
  2357         /**
       
  2358          * Phone store info (return pointer to client)
       
  2359          */         
       
  2360         RMobilePhoneStore::TMobilePhoneStoreInfoV1* iRetPhoneStoreInfo;
       
  2361 
       
  2362         /**
       
  2363          * Service Table (return pointer to client)
       
  2364          */         
       
  2365         RMobilePhone::TMobilePhoneServiceTableV1* iRetTableData;
       
  2366         
       
  2367         /**
       
  2368          * Service Table (SIM )(return pointer to client)
       
  2369          */         
       
  2370         RMobilePhone::TMobilePhoneServiceTableV1* iServiceTableDataCache;
       
  2371         
       
  2372         /**
       
  2373          * Service Table (USIM) (return pointer to client)
       
  2374          */         
       
  2375         RMobilePhone::TMobilePhoneServiceTableV1* iServiceTableUSIMDataCache;
       
  2376         
       
  2377         /**
       
  2378          * Pending Service Table cache request
       
  2379          */         
       
  2380         TServiceTableRequest iPendingServiceTableCacheReq;
       
  2381         
       
  2382         /** 
       
  2383          * Pending Service Table request
       
  2384          */         
       
  2385         TServiceTableRequest iPendingServiceTableReq;
       
  2386         
       
  2387         /**
       
  2388          * A table for phone request handles
       
  2389          */         
       
  2390         TTsyReqHandle iPhoneReqHandles[EMultimodePhoneMaxNumOfRequests];
       
  2391 
       
  2392         /**
       
  2393          * Pointer to CMmMessageManagerBase
       
  2394          */                  
       
  2395         CMmMessageManagerBase* iMessageManager;
       
  2396 
       
  2397         /**
       
  2398          * a Pointer to the broadcast object
       
  2399          */         
       
  2400         CMmBroadcastTsy* iMmBroadcastTsy;
       
  2401 
       
  2402         /** 
       
  2403          * new fdn setting
       
  2404          */         
       
  2405         RMobilePhone::TMobilePhoneFdnSetting* iRetFdnSetting;
       
  2406 
       
  2407         /**
       
  2408          * TSY req handle store
       
  2409          * Own.
       
  2410          */                  
       
  2411         CMmTsyReqHandleStore* iTsyReqHandleStore;
       
  2412         
       
  2413         /**
       
  2414          * TSY request type
       
  2415          */         
       
  2416         TPhoneRequestTypes iReqHandleType;
       
  2417 
       
  2418         /**
       
  2419          * A pointer to call object waiting for incoming call
       
  2420          */         
       
  2421         CMmCallTsy* iMmWaitingDataCall; 
       
  2422 
       
  2423         /**
       
  2424          * Als Line status
       
  2425          */         
       
  2426         RMobilePhone::TMobilePhoneALSLine iAlsLine;
       
  2427 
       
  2428         /**
       
  2429          * Temporary Als Line status, for set operation
       
  2430          */         
       
  2431         RMobilePhone::TMobilePhoneALSLine iTempAlsLine;
       
  2432 
       
  2433         /**
       
  2434          * DOS BootState
       
  2435          */         
       
  2436         CNosBootState iBootState;
       
  2437 
       
  2438         /**
       
  2439          * Phonebook state
       
  2440          */         
       
  2441         CStorageInfoData* iPhoneBookState;
       
  2442 
       
  2443 
       
  2444 #ifdef REQHANDLE_TIMER
       
  2445 
       
  2446         /**
       
  2447          * Timer
       
  2448          * Own.         
       
  2449          */         
       
  2450         CResponseTimer *iReqHandleTimer;
       
  2451         
       
  2452         /**
       
  2453          * Time store
       
  2454          * Own.         
       
  2455          */         
       
  2456         CResponseTimerStore *iTimeStampStore;
       
  2457 
       
  2458 #endif
       
  2459         /**
       
  2460          * timer for air time duration monitoring
       
  2461          * Own.
       
  2462          */                  
       
  2463         CHeartbeatRunner* iAirTimeDurationTimer;
       
  2464 
       
  2465         /**
       
  2466          * Amount of active calls for air time duration calculation
       
  2467          */         
       
  2468         TInt iAmountOfActiveCalls;
       
  2469 
       
  2470         /**
       
  2471          * Offline
       
  2472          */         
       
  2473         TRfStateInfo iStateInfo;
       
  2474         TRfStatus iRfStatusFlag;
       
  2475 
       
  2476         /**
       
  2477          * Pointer to the NetTsy class
       
  2478          * Own.
       
  2479          */                  
       
  2480         CMmNetTsy* iMmNetTsy;
       
  2481 
       
  2482         /**
       
  2483          * Pointer to the DtmfTsy class
       
  2484          * Own.
       
  2485          */                  
       
  2486         CMmDtmfTsy* iMmDtmfTsy;
       
  2487 
       
  2488         /**
       
  2489          * Pointer to the SupplServTsy class
       
  2490          * Own.         
       
  2491          */         
       
  2492         CMmSupplServTsy* iMmSupplServTsy;
       
  2493         
       
  2494         /**
       
  2495          * Pointer to the SecurityTsy class
       
  2496          * Own.         
       
  2497          */ 
       
  2498         CMmSecurityTsy* iMmSecurityTsy;
       
  2499         
       
  2500         /**
       
  2501          * Fdn Status
       
  2502          */                 
       
  2503         RMobilePhone::TMobilePhoneFdnStatus* iRetGetFdnStatus;
       
  2504 		
       
  2505 		/**
       
  2506 		 * Pointer to struct for storing get servicetable parameters
       
  2507 		 */
       
  2508 		RPointerArray< TServiceTableRequests > iServiceTableRequests;
       
  2509 		        
       
  2510         /**
       
  2511          * state of phone indicator
       
  2512          */         
       
  2513         RPointerArray< TSubscriberIdRequest > iSubscriberIdRequests;
       
  2514 
       
  2515         /**
       
  2516          * Array for buffering Phone Id requests
       
  2517          */         
       
  2518         RPointerArray< TGetPhoneIdRequest > iGetPhoneIdRequests;
       
  2519         
       
  2520         /**
       
  2521          * Array for buffering Customer service profile requests
       
  2522          */             
       
  2523         RPointerArray< TCustomerServiceProfileIdRequest > 
       
  2524             iCustomerServiceProfileRequests;
       
  2525         
       
  2526         /**
       
  2527          * Array for buffering Get Als Line requests
       
  2528          */             
       
  2529         RPointerArray< TGetAlsLineRequest > iGetAlsLineRequests;
       
  2530         
       
  2531         /**
       
  2532          * Indicator state
       
  2533          */                         
       
  2534         TUint32 iIndicatorState;
       
  2535 
       
  2536         /**
       
  2537          * Indicator state
       
  2538          */ 
       
  2539         TUint32* iRetIndicatorState;
       
  2540         
       
  2541         /**
       
  2542          * Pointer to the IMS authentication data
       
  2543          */         
       
  2544         TDes8* iIMSAuthenticationData; 
       
  2545         
       
  2546         /** 
       
  2547          * Pointer to the Mailbox dialling numbers data
       
  2548          */             
       
  2549         TDes8* iMailBoxData;
       
  2550         
       
  2551         /** 
       
  2552          * Number of APNs in ACL (return pointer to client)
       
  2553          * Not Own.
       
  2554          */
       
  2555         TUint32* iRetAPNEntries;
       
  2556         
       
  2557         /**
       
  2558          * APN name (return pointer to client)
       
  2559          * Not Own.
       
  2560          */
       
  2561         TDes8* iRetAPNname;
       
  2562         
       
  2563         /**
       
  2564          * Sim support for ALS
       
  2565          */
       
  2566         TBool iAlsSupportedBySim;
       
  2567         
       
  2568         /**
       
  2569          * Pointer to Central Repository
       
  2570          * Own.
       
  2571          */
       
  2572         CRepository* iCentRep;
       
  2573         
       
  2574         /**
       
  2575          * Indicates about sim refresh registration status
       
  2576          */ 
       
  2577         TBool iSimRefreshRegisterOk;
       
  2578         
       
  2579         /**
       
  2580          * Indicates that GetServiceTableL method is called
       
  2581          */
       
  2582         TBool iCalledOnGet;
       
  2583         
       
  2584         /** 
       
  2585          * Pointer to struct for storing get servicetable parameters 
       
  2586          * Own.
       
  2587          */
       
  2588         TGetServiceTableRequest* iServiceTableReq; 
       
  2589         
       
  2590         /**
       
  2591          * Service table cache error
       
  2592          */
       
  2593         TInt iCacheServiceTableError;
       
  2594 
       
  2595         /**
       
  2596          * Pointer to Public Central Repository
       
  2597          * Own.
       
  2598          */
       
  2599         CRepository* iCFISCentRep;
       
  2600         
       
  2601         /**
       
  2602          * Pointer to MWIS Central Repository
       
  2603          * Own.
       
  2604          */
       
  2605         CRepository* iMWISCentRep;
       
  2606         
       
  2607         /**
       
  2608          * Pointer to CFIS Private Central Repository
       
  2609          * Own.
       
  2610          */
       
  2611         CRepository* iCFISPrivateCentRep;
       
  2612         
       
  2613         /**
       
  2614          * Get Subscriber Id requested from CommonTSY
       
  2615          */
       
  2616         TBool iTSYSubscriberIdReq;
       
  2617 
       
  2618         /**
       
  2619          * Pointer to ACL status
       
  2620          * Not Own.         
       
  2621          */
       
  2622         RMobilePhone::TAPNControlListServiceStatus* iRetAclStatus;
       
  2623         
       
  2624         /**
       
  2625          * Pointer to ACL status
       
  2626          * Not Own.         
       
  2627          */
       
  2628         RMobilePhone::TAPNControlListServiceStatus* iSetAclStatus;
       
  2629         
       
  2630         /**
       
  2631          * Pointer to ACL status
       
  2632          * Not Own.         
       
  2633          */
       
  2634         RMobilePhone::TAPNControlListServiceStatus* iRetNotifyAclStatus;
       
  2635         
       
  2636         /**
       
  2637          * Array for storing get service provider name requests
       
  2638          */         
       
  2639         RPointerArray< TServiceProviderNameRequest > 
       
  2640             iServiceProviderNameRequests;
       
  2641             
       
  2642         /**
       
  2643          * Pointer to LicenseeTsy instance
       
  2644          */     
       
  2645         MLtsyFactoryBase* iLtsyFactory;
       
  2646 	    	
       
  2647 	    /**
       
  2648 	     * A boolean to tell CSP file request that 
       
  2649 	     * it's called internally during the boot
       
  2650 	     */
       
  2651 	    TBool iCspFileQueryInBoot;
       
  2652        
       
  2653 	    /**
       
  2654 	     * A boolean to tell ALS support request that 
       
  2655 	     * it's called internally during the boot
       
  2656 	     */
       
  2657 	    TBool iAlsQueryInBoot;
       
  2658 	    	
       
  2659 	    /**
       
  2660 	     * A boolean to hold CSP file's ALS data
       
  2661 	     */
       
  2662 	    TBool iCspFileALS;
       
  2663 	    	
       
  2664 	    /**
       
  2665 	     * A boolean to hold ALS Pp Support
       
  2666 	     * it's called internally during the boot
       
  2667 	     */
       
  2668 	    TBool iAlsPpSupport;
       
  2669 	    	
       
  2670 	    /**
       
  2671 	     * A boolean to tell if CSP file's ALS data
       
  2672 	     * is being set into ALS state
       
  2673 	     */
       
  2674 	    TBool iCspFileAlsSet;
       
  2675 	    
       
  2676 	    /**
       
  2677 	     * A boolean to tell if HomeZoneParams
       
  2678 	     * has been checked
       
  2679 	     */
       
  2680 	    TBool iViagHomeZoneParamsChecked;
       
  2681 	    
       
  2682         /**
       
  2683 		*Pointer to the Telephony Audio Control instance
       
  2684 		*/ 
       
  2685         MTelephonyAudioControl* iTelephonyAudioControl;
       
  2686 	    
       
  2687         /** 
       
  2688 		*Attribute to tell the status of PB initialization
       
  2689 		*/
       
  2690         TBool iIsInitializationActive;		
       
  2691 
       
  2692         /*
       
  2693          * Attribute to tell the status is modem status ready
       
  2694          */
       
  2695         TBool iIsModemReady;
       
  2696         
       
  2697         // ==== For getting Battery info from HWRM ====	    
       
  2698 	    /**
       
  2699 	    * Pointer to CHWRMPower instance
       
  2700 	    */
       
  2701 	    CHWRMPower* iPowerManager;
       
  2702 	    
       
  2703 	    /**
       
  2704 	    * Pointer to the BatteryInfoObserver
       
  2705 	    */	    
       
  2706 	    CBatteryInfoObserver* iBattery;
       
  2707 	    
       
  2708 	    /**
       
  2709 	    * Pointer to the ChargingStatusObserver
       
  2710 	    */
       
  2711         CChargingStatusObserver* iChargingStatus;
       
  2712     };
       
  2713 
       
  2714 #endif // CMMPHONETSY_H
       
  2715 
       
  2716 // End of File