phoneplugins/csplugin/inc/cspcall.h
changeset 65 2a5d4ab426d3
parent 60 1eef62f5c541
equal deleted inserted replaced
60:1eef62f5c541 65:2a5d4ab426d3
     1 /*
     1 /*
     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
     3 * All rights reserved.
     3 * All rights reserved.
     4 * This component and the accompanying materials are made available
     4 * This component and the accompanying materials are made available
     5 * under the terms of "Eclipse Public License v1.0"
     5 * under the terms of "Eclipse Public License v1.0"
     6 * which accompanies this distribution, and is available
     6 * which accompanies this distribution, and is available
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
    32 #include "cspetelcallrequester.h" // For the requester and TRequestType
    32 #include "cspetelcallrequester.h" // For the requester and TRequestType
    33 #include "mcspcallobserver.h"
    33 #include "mcspcallobserver.h"
    34 #include "mcspcallerrorobserver.h"
    34 #include "mcspcallerrorobserver.h"
    35 #include "mcspuusmessageobserver.h"
    35 #include "mcspuusmessageobserver.h"
    36 #include "mcspcallcommandhandling.h"
    36 #include "mcspcallcommandhandling.h"
    37 
    37 #include "mcspaudiohandlerobserver.h"
    38 
    38 
    39 class MCCPForwardProvider;
    39 class MCCPForwardProvider;
    40 class CSPForwardProvider;
    40 class CSPForwardProvider;
    41 class CSPTransferProvider;
    41 class CSPTransferProvider;
    42 class RMobileCall;
    42 class RMobileCall;
    44 class CSPEtelCallEventMonitor;
    44 class CSPEtelCallEventMonitor;
    45 class CSPCallInfoMonitor;
    45 class CSPCallInfoMonitor;
    46 class CSPEtelCallCapsMonitor;
    46 class CSPEtelCallCapsMonitor;
    47 class CSPTransferProvider;
    47 class CSPTransferProvider;
    48 class CSPEtelCallCapsMonitor;
    48 class CSPEtelCallCapsMonitor;
    49 class CSPAudioHandler;
    49 class CSPAudioHandlerBase;
    50 class MCSPCommonInfo;
    50 class MCSPCommonInfo;
    51 class CSPUUIMonitor;
    51 class CSPUUIMonitor;
    52 class CSPUUIMessageSender;
    52 class CSPUUIMessageSender;
    53 
    53 
    54 
    54 
    61 class CSPCall : public CBase,
    61 class CSPCall : public CBase,
    62                 public MCCPCSCall,
    62                 public MCCPCSCall,
    63                 public MCSPCallObserver,
    63                 public MCSPCallObserver,
    64                 public MCSPCallErrorObserver,
    64                 public MCSPCallErrorObserver,
    65                 public MCSPUUSMessageObserver,
    65                 public MCSPUUSMessageObserver,
    66                 public MCCPCallCommandHandling
    66                 public MCCPCallCommandHandling,
       
    67                 public MCSPAudioHandlerObserver
    67     {
    68     {
    68     public:
    69     public:
    69         /*
    70         /*
    70         * C++ default destructor
    71         * C++ default destructor
    71         */
    72         */
    72         virtual ~CSPCall( );
    73         virtual ~CSPCall( );
    73        
    74 
    74         /** 
    75         /**
    75         * ETel call name accessor.
    76         * ETel call name accessor.
    76         * @return system wide error code
    77         * @return system wide error code
    77         */
    78         */
    78         void CallName( TName& aCallName );
    79         void CallName( TName& aCallName );
    79         
    80 
    80         /**
    81         /**
    81         * Sets the audio handler for the call.
    82         * Sets the audio handler for the call.
    82         * @param aHandler audio handler
    83         * @param aHandler audio handler
    83         */
    84         */
    84         void SetAudioHandler( CSPAudioHandler* aHandler );
    85         void SetAudioHandler( CSPAudioHandlerBase* aHandler );
    85         
    86 
    86         /**
    87         /**
    87          * Security setting change notification.
    88          * Security setting change notification.
    88          * @param aValue new value
    89          * @param aValue new value
    89          */
    90          */
    90         void SecuritySettingChanged( TInt aValue );
    91         void SecuritySettingChanged( TInt aValue );
    91         
    92 
    92         /**
    93         /**
    93          * Remote alerting tone status changed notification.
    94          * Remote alerting tone status changed notification.
    94          * @param aNewStatus New remote alerting tone status.
    95          * @param aNewStatus New remote alerting tone status.
    95          */
    96          */
    96         void RemoteAlertingToneStatusChanged(
    97         void RemoteAlertingToneStatusChanged(
    98 
    99 
    99         /**
   100         /**
   100          * Set iDontReportTerm flag value to ETrue.
   101          * Set iDontReportTerm flag value to ETrue.
   101          */
   102          */
   102         void DontReportTerminationError();
   103         void DontReportTerminationError();
   103         
   104 
   104 // from base class MCSPCallObserver
   105 // from base class MCSPCallObserver
   105 
   106 
   106         /**
   107         /**
   107         * Updates the call event for observers.
   108         * Updates the call event for observers.
   108         * @param aEvent the event to be notified
   109         * @param aEvent the event to be notified
   109         */
   110         */
   110         virtual void NotifyForwardEventOccurred( 
   111         virtual void NotifyForwardEventOccurred(
   111                         MCCPForwardObserver::TCCPForwardEvent aEvent );
   112                         MCCPForwardObserver::TCCPForwardEvent aEvent );
   112 
   113 
   113         /**
   114         /**
   114         * Updates the state change and forwards the state for observer.
   115         * Updates the state change and forwards the state for observer.
   115         * @param aState new state (ETel) of the call 
   116         * @param aState new state (ETel) of the call
   116         */
   117         */
   117         virtual void NotifyCallStateChangedETel( 
   118         virtual void NotifyCallStateChangedETel(
   118             RMobileCall::TMobileCallStatus aState );
   119             RMobileCall::TMobileCallStatus aState );
   119 
   120 
   120         /**
   121         /**
   121         * Updates the call event for observers.
   122         * Updates the call event for observers.
   122         * @param aEvent the event to be notified
   123         * @param aEvent the event to be notified
   123         */
   124         */
   124         virtual void NotifyCallEventOccurred( 
   125         virtual void NotifyCallEventOccurred(
   125             MCCPCallObserver::TCCPCallEvent aEvent );
   126             MCCPCallObserver::TCCPCallEvent aEvent );
   126 
   127 
   127         /**
   128         /**
   128         * Updates the transfer event for observers.
   129         * Updates the transfer event for observers.
   129         * @param aEvent the event to be notified
   130         * @param aEvent the event to be notified
   130         */
   131         */
   131         virtual void NotifyTransferCallEventOccurred( 
   132         virtual void NotifyTransferCallEventOccurred(
   132                         MCCPTransferObserver::TCCPTransferEvent aEvent );
   133                         MCCPTransferObserver::TCCPTransferEvent aEvent );
   133         
   134 
   134         /**
   135         /**
   135         * Notifies changed call capabilities.
   136         * Notifies changed call capabilities.
   136         * @param aCapsFlags new capability flags
   137         * @param aCapsFlags new capability flags
   137         */
   138         */
   138 
   139 
   139         virtual void CallCapsChanged( const TUint32 aCapsFlags );
   140         virtual void CallCapsChanged( const TUint32 aCapsFlags );
   140         
   141 
   141 // from base class MCSPCallErrorObserver        
   142 // from base class MCSPCallErrorObserver
   142     
   143 
   143         /**
   144         /**
   144         * From MCSPCallErrorObserver
   145         * From MCSPCallErrorObserver
   145         * Dial request failed notification.
   146         * Dial request failed notification.
   146         * @param aErrorCode request failing error code
   147         * @param aErrorCode request failing error code
   147         */
   148         */
   151         * From MCSPCallErrorObserver
   152         * From MCSPCallErrorObserver
   152         * Emergency dial request failed notification.
   153         * Emergency dial request failed notification.
   153         * @param aErrorCode request failing error code
   154         * @param aErrorCode request failing error code
   154         */
   155         */
   155         void EmergencyDialRequestFailed( TInt aErrorCode );
   156         void EmergencyDialRequestFailed( TInt aErrorCode );
   156         
   157 
   157         /**
   158         /**
   158         * From MCSPCallErrorObserver
   159         * From MCSPCallErrorObserver
   159         * Notifies about error situation for CCE.
   160         * Notifies about error situation for CCE.
   160         */
   161         */
   161         virtual void NotifyErrorOccurred( TCCPError aError );
   162         virtual void NotifyErrorOccurred( TCCPError aError );
   162 
   163 
   163 // from base class MCSPUUSMessageObserver
   164 // from base class MCSPUUSMessageObserver
   164         
   165 
   165         /**
   166         /**
   166         * From MCSPUUSMessageObserver
   167         * From MCSPUUSMessageObserver
   167         * UUS message received notification. 
   168         * UUS message received notification. 
   168         */
   169         */
   169         void UUSMessageReceived( const TDesC& aMessage );        
   170         void UUSMessageReceived( const TDesC& aMessage );        
   181 
   182 
   182         /**
   183         /**
   183         * From MCCPCSCall
   184         * From MCCPCSCall
   184         * Gets the calls data call capabilities
   185         * Gets the calls data call capabilities
   185         * @param aCaps TMobileCallDataCapsV1
   186         * @param aCaps TMobileCallDataCapsV1
   186         * @return KErrNone if the function member was successful, 
   187         * @return KErrNone if the function member was successful,
   187         *        KErrNotSupported if call doesn't support circuit switched data
   188         *        KErrNotSupported if call doesn't support circuit switched data
   188         *        KErrNotFound if this call is not a data call
   189         *        KErrNotFound if this call is not a data call
   189         */
   190         */
   190         virtual TInt GetMobileDataCallCaps( TDes8& aCaps ) const;
   191         virtual TInt GetMobileDataCallCaps( TDes8& aCaps ) const;
   191 
   192 
   192 // from base class MCCPCall
   193 // from base class MCCPCall
   193         
   194 
   194         /**
   195         /**
   195         * From MCCPCall
   196         * From MCCPCall
   196         * Answers to an incoming call.
   197         * Answers to an incoming call.
   197         * @return system wide error code
   198         * @return system wide error code
   198         */
   199         */
   205         */
   206         */
   206         virtual TInt Reject();
   207         virtual TInt Reject();
   207 
   208 
   208         /**
   209         /**
   209         * From MCCPCall
   210         * From MCCPCall
   210         * Reguests plug-in to queue the call.     
   211         * Reguests plug-in to queue the call.
   211         * @return system wide error code    
   212         * @return system wide error code
   212         */
   213         */
   213         virtual TInt Queue();
   214         virtual TInt Queue();
   214 
   215 
   215         /**
   216         /**
   216         * From MCCPCall
   217         * From MCCPCall
   217         * Starts dialing to remote party
   218         * Starts dialing to remote party
   218         * @return system wide error code
   219         * @return system wide error code
   219         */
   220         */
   220         virtual TInt Dial();
   221         virtual TInt Dial();
   221         
   222 
   222         /**
   223         /**
   223         * From MCCPCSCall
   224         * From MCCPCSCall
   224         * Starts dialing to recipient
   225         * Starts dialing to recipient
   225         * @param aCallParams Call parameters used 
   226         * @param aCallParams Call parameters used
   226         *   by the TSY (TCallParamsPckg)
   227         *   by the TSY (TCallParamsPckg)
   227         * @return system wide error code
   228         * @return system wide error code
   228         */
   229         */
   229         TInt Dial( const TDesC8& aCallParams );
   230         TInt Dial( const TDesC8& aCallParams );
   230 
   231 
   332         * @return TBool ETrue if security is enabled, else EFalse.
   333         * @return TBool ETrue if security is enabled, else EFalse.
   333         */
   334         */
   334         virtual TBool IsSecured() const;
   335         virtual TBool IsSecured() const;
   335 
   336 
   336         /**
   337         /**
   337         * From MCCPCall 
   338         * From MCCPCall
   338         * Get call's secure specified status.
   339         * Get call's secure specified status.
   339         * @return TBool ETrue if secure specified 
   340         * @return TBool ETrue if secure specified
   340         */
   341         */
   341         virtual TBool SecureSpecified() const;
   342         virtual TBool SecureSpecified() const;
   342 
   343 
   343         /**
   344         /**
   344         * From MCCPCall  
   345         * From MCCPCall
   345         * Set call parameters.
   346         * Set call parameters.
   346         * @param aNewParams New call paramater information.
   347         * @param aNewParams New call paramater information.
   347         */
   348         */
   348         virtual void SetParameters( const CCCPCallParameters& aNewParams );
   349         virtual void SetParameters( const CCCPCallParameters& aNewParams );
   349         
   350 
   350         /**
   351         /**
   351         * From MCCPCall 
   352         * From MCCPCall
   352         * Cet call parameters.
   353         * Cet call parameters.
   353         * @return Current call paramater information.
   354         * @return Current call paramater information.
   354         */
   355         */
   355         virtual const CCCPCallParameters& Parameters() const;
   356         virtual const CCCPCallParameters& Parameters() const;
   356 
   357 
   357         /**
   358         /**
   358         * From MCCPCall 
   359         * From MCCPCall
   359         * Get Forward provider
   360         * Get Forward provider
   360         * @param aObserver - observer class for forward events
   361         * @param aObserver - observer class for forward events
   361         * @return Pointer to MCCPForwardProvider if succesfull, NULL if not available
   362         * @return Pointer to MCCPForwardProvider if succesfull, NULL if not available
   362         * @leave on error case system error code
   363         * @leave on error case system error code
   363         */
   364         */
   364         virtual MCCPForwardProvider* ForwardProviderL( const MCCPForwardObserver& aObserver );
   365         virtual MCCPForwardProvider* ForwardProviderL( const MCCPForwardObserver& aObserver );
   365 
   366 
   366         /**
   367         /**
   367         * From MCCPCall 
   368         * From MCCPCall
   368         * Get Call transfer provider
   369         * Get Call transfer provider
   369         * @param aObserver - observer class for transfer events
   370         * @param aObserver - observer class for transfer events
   370         * @return Pointer to MCCPTransferProvider if succesfull, NULL if not available
   371         * @return Pointer to MCCPTransferProvider if succesfull, NULL if not available
   371         * @leave on error case system error code
   372         * @leave on error case system error code
   372         */
   373         */
   373         virtual MCCPTransferProvider* TransferProviderL( const MCCPTransferObserver& aObserver );
   374         virtual MCCPTransferProvider* TransferProviderL( const MCCPTransferObserver& aObserver );
   374           
   375 
   375         /**
   376         /**
   376         * From MCCPCall  
   377         * From MCCPCall
   377         * Adds a new observer for MCCECall object. Called in MT call case. In MO 
   378         * Adds a new observer for MCCECall object. Called in MT call case. In MO
   378         * case observer will be given at call construction.
   379         * case observer will be given at call construction.
   379         * Plug-in dependent feature if duplicates or more than one observers 
   380         * Plug-in dependent feature if duplicates or more than one observers
   380         * are allowed or not. Currently CCE will set only one observer.
   381         * are allowed or not. Currently CCE will set only one observer.
   381         * @param aObserver Observer
   382         * @param aObserver Observer
   382         * @leave system error if observer adding fails
   383         * @leave system error if observer adding fails
   383         */
   384         */
   384         virtual void AddObserverL( const MCCPCallObserver& aObserver );
   385         virtual void AddObserverL( const MCCPCallObserver& aObserver );
   385 
   386 
   386         /**
   387         /**
   387         * From MCCPCall  
   388         * From MCCPCall
   388         * Remove an observer.
   389         * Remove an observer.
   389         * @param aObserver Observer
   390         * @param aObserver Observer
   390         * @return KErrNone if removed succesfully. KErrNotFound if observer was not found.
   391         * @return KErrNone if removed succesfully. KErrNotFound if observer was not found.
   391         * Any other system error depending on the error.
   392         * Any other system error depending on the error.
   392         */
   393         */
   393         virtual TInt RemoveObserver( const MCCPCallObserver& aObserver );
   394         virtual TInt RemoveObserver( const MCCPCallObserver& aObserver );
   394         
   395 
   395         /**
   396         /**
   396         * From MCCPCall 
   397         * From MCCPCall
   397         * Returns the inband tone associated to an error condition or a state transition of a call.
   398         * Returns the inband tone associated to an error condition or a state transition of a call.
   398         * See defenition for TCCPTone.
   399         * See defenition for TCCPTone.
   399         * @since S60 3.2
   400         * @since S60 3.2
   400         * @param None.
   401         * @param None.
   401         * @return TCCPTone Used tone.
   402         * @return TCCPTone Used tone.
   402         */
   403         */
   403         TCCPTone Tone() const;
   404         TCCPTone Tone() const;
   404 
   405 
   405 // from base class MCCPCSCall
   406 // from base class MCCPCSCall
   406         
   407 
   407         /**
   408         /**
   408         * From MCCPCSCall
   409         * From MCCPCSCall
   409         * Indicates that FDN check is not used for dial.
   410         * Indicates that FDN check is not used for dial.
   410         */
   411         */
   411         virtual void NoFDNCheck( );
   412         virtual void NoFDNCheck( );
   412         
   413 
   413         /**
   414         /**
   414         * From MCCPCSCall 
   415         * From MCCPCSCall
   415         * Log dialed  number. SAT related, check if dialed number is to be logged or not.
   416         * Log dialed  number. SAT related, check if dialed number is to be logged or not.
   416         * @since S60 5.0
   417         * @since S60 5.0
   417         * @param None
   418         * @param None
   418         * @return Log dialed number or not.
   419         * @return Log dialed number or not.
   419         */
   420         */
   420         virtual TBool LogDialedNumber() const;
   421         virtual TBool LogDialedNumber() const;
   421     
   422 
   422 // from base class MCCPCallCommandHandling
   423 // from base class MCCPCallCommandHandling
   423         
   424 
   424         /**
   425         /**
   425         * Perform answer command.
   426         * Perform answer command.
   426         * @return system wide error code
   427         * @return system wide error code
   427         */
   428         */
   428         TInt PerformAnswerRequest();
   429         TInt PerformAnswerRequest();
   429         
   430 
   430         /**
   431         /**
   431         * Perform dial command.
   432         * Perform dial command.
   432         * @return system wide error code
   433         * @return system wide error code
   433         */
   434         */
   434         TInt PerformDialRequest();
   435         TInt PerformDialRequest();
   435         
   436 
       
   437 // from base class MCSPAudioHandlerObserver
       
   438 
       
   439         /*
       
   440          * Callback received when call audio control streams fail to start
       
   441          * within timeout specified in ReportAudioFailureAfterTimeout().
       
   442          */
       
   443         void AudioStartingFailed();
       
   444 
   436     protected:
   445     protected:
   437             
   446 
   438         /**
   447         /**
   439         * Starts dialing to recipient.
   448         * Starts dialing to recipient.
   440         * Bypasses FDN check according to aFdnCheck.
   449         * Bypasses FDN check according to aFdnCheck.
   441         * @param aFdnCheck True if FDN checking is used
   450         * @param aFdnCheck True if FDN checking is used
   442         * @return system wide error code
   451         * @return system wide error code
   443         */
   452         */
   444         virtual TInt DialFdnCond( TBool aFdnCheck ) = 0;
   453         virtual TInt DialFdnCond( TBool aFdnCheck ) = 0;
   445                 
   454 
   446     protected:
   455     protected:
   447     
   456 
   448         /**
   457         /**
   449         * C++ default constructor.  
   458         * C++ default constructor.
   450         * 
   459         *
   451         * @param aLine line of the call 
   460         * @param aLine line of the call
   452         * @param aMobileOriginated is call mobile originated 
   461         * @param aMobileOriginated is call mobile originated
   453         * @param aName contains call name (mobile terminated) or phone number (mobile originated)
   462         * @param aName contains call name (mobile terminated) or phone number (mobile originated)
   454         * @param aCommonInfo reference to common info interface 
   463         * @param aCommonInfo reference to common info interface
   455         * @param aIsEmergencyCall is emergency call 
   464         * @param aIsEmergencyCall is emergency call
   456         */
   465         */
   457         CSPCall(  RMobileLine& aLine, 
   466         CSPCall(  RMobileLine& aLine,
   458                   TBool aMobileOriginated,
   467                   TBool aMobileOriginated,
   459                   const TDesC& aName,
   468                   const TDesC& aName,
   460                   MCSPCommonInfo& aCommonInfo,
   469                   MCSPCommonInfo& aCommonInfo,
   461                   TBool aIsEmergencyCall );
   470                   TBool aIsEmergencyCall );
   462                   
   471 
   463         /*
   472         /*
   464         * Constructing 2nd phase.
   473         * Constructing 2nd phase.
   465         * @param aParams call parameters  
   474         * @param aParams call parameters
   466         */
   475         */
   467         virtual void ConstructL( const CCCECallParameters& aParams );
   476         virtual void ConstructL( const CCCECallParameters& aParams );
   468         
   477 
   469         /*
   478         /*
   470         * Notifies the ringing state to observers.
   479         * Notifies the ringing state to observers.
   471         */
   480         */
   472         virtual void NotifyRingingState();
   481         virtual void NotifyRingingState();
   473         
   482 
   474         /**
   483         /**
   475         * Mapping ETel state to CCP state.
   484         * Mapping ETel state to CCP state.
   476         * @param aEtelState an ETel state
   485         * @param aEtelState an ETel state
   477         * @return corresponding CCP state
   486         * @return corresponding CCP state
   478         */
   487         */
   483         * From MCSPCallObserver 
   492         * From MCSPCallObserver 
   484         * Updates the state change including inband tones 
   493         * Updates the state change including inband tones 
   485         * played by network and forwards the state for observer.
   494         * played by network and forwards the state for observer.
   486         * @param aState new state of the call
   495         * @param aState new state of the call
   487         */
   496         */
   488         virtual void NotifyCallStateChangedWithInband( 
   497         virtual void NotifyCallStateChangedWithInband(
   489             MCCPCallObserver::TCCPCallState aState );
   498             MCCPCallObserver::TCCPCallState aState );
   490 
   499 
   491         /**
   500         /**
   492         * Updates the state change 
   501         * Updates the state change
   493         * and forwards the state for observer.
   502         * and forwards the state for observer.
   494         * @param aState new state of the call
   503         * @param aState new state of the call
   495         */
   504         */
   496         virtual void NotifyCallStateChanged( 
   505         virtual void NotifyCallStateChanged(
   497             MCCPCallObserver::TCCPCallState aState );
   506             MCCPCallObserver::TCCPCallState aState );
   498             
   507 
   499         /**
   508         /**
   500         * From MCSPCallObserver
   509         * From MCSPCallObserver
   501         * Notify that remote party info has changed.        
   510         * Notify that remote party info has changed.
   502         * @param aRemotePartyName new remote party name
   511         * @param aRemotePartyName new remote party name
   503         * @param aRemotePartyNumber new remote party number
   512         * @param aRemotePartyNumber new remote party number
   504         */
   513         */
   505         virtual void NotifyRemotePartyInfoChanged(                
   514         virtual void NotifyRemotePartyInfoChanged(
   506             const TDesC& aRemotePartyName,
   515             const TDesC& aRemotePartyName,
   507             const TDesC& aRemotePartyNumber );
   516             const TDesC& aRemotePartyNumber );
   508 
   517 
   509         /**
   518         /**
   510         * Open call handle.  
   519         * Open call handle.
   511         * Opens a new call handle for MO call  
   520         * Opens a new call handle for MO call
   512         * and an existing handle for MT call.    
   521         * and an existing handle for MT call.
   513         */
   522         */
   514         virtual void OpenCallHandleL();
   523         virtual void OpenCallHandleL();
   515 
   524 
   516         /**
   525         /**
   517         * Update call info data including call name,  
   526         * Update call info data including call name,
   518         * remote name and number data.  
   527         * remote name and number data.
   519         */
   528         */
   520         virtual void UpdateCallInfo();
   529         virtual void UpdateCallInfo();
   521         
   530         
   522         /**
   531         /**
   523          * Implementation for UpdateCallInfo().       
   532          * Implementation for UpdateCallInfo().       
   539 
   548 
   540         /**
   549         /**
   541         * Check and notify call termination error.
   550         * Check and notify call termination error.
   542         */
   551         */
   543         void CheckAndNotifyTerminationError();
   552         void CheckAndNotifyTerminationError();
   544         
   553 
   545         /**
   554         /**
   546         * Error from iExitCode.
   555         * Error from iExitCode.
   547         */
   556         */
   548         TInt ExitCodeError() const;
   557         TInt ExitCodeError() const;
   549         
   558 
   550         /**
   559         /**
   551         * Update call name number info.   
   560         * Update call name number info.
   552         * @param aCallInfo RMobileCall::TMobileCallInfoV3
   561         * @param aCallInfo RMobileCall::TMobileCallInfoV3
   553         * @param aCallCreatedByMonitor, set:  
   562         * @param aCallCreatedByMonitor, set:
   554         *       EFalse for calls added by plugin owner
   563         *       EFalse for calls added by plugin owner
   555         *       ETrue for calls added by ETel status monitor  
   564         *       ETrue for calls added by ETel status monitor
   556         */
   565         */
   557         void UpdateCallNameNumberInfo(
   566         void UpdateCallNameNumberInfo(
   558                 const RMobileCall::TMobileCallInfoV3& aCallInfo, 
   567                 const RMobileCall::TMobileCallInfoV3& aCallInfo, 
   559                 TBool aCallAddedByMonitor ); 
   568                 TBool aCallAddedByMonitor ); 
   560 
   569 
   561         /**
   570         /**
   562         * Open new call.
   571         * Open new call.
   563         * New call is opened when the plugin owner adds the new 
   572         * New call is opened when the plugin owner adds the new
   564         * call (compare to OpenExistingCall where call is added by 
   573         * call (compare to OpenExistingCall where call is added by
   565         * ETel monitor).  
   574         * ETel monitor).
   566         */
   575         */
   567         void OpenNewCall(); 
   576         void OpenNewCall();
   568 
   577 
   569         /**
   578         /**
   570         * Open existing call.
   579         * Open existing call.
   571         * Existing call is opened if one of the ETel
   580         * Existing call is opened if one of the ETel
   572         * monitors (incoming call monitor or line status monitor) 
   581         * monitors (incoming call monitor or line status monitor)
   573         * has added the call and no new call needs to be 
   582         * has added the call and no new call needs to be
   574         * opened.    
   583         * opened.
   575         * @param aName name of the existing call   
   584         * @param aName name of the existing call
   576         */
   585         */
   577         void OpenExistingCallL( const TDesC& aName ); 
   586         void OpenExistingCallL( const TDesC& aName );
   578         
   587 
   579     private:
   588     private:
   580 
   589 
   581         /**
   590         /**
   582         * Create call handlers for call requests and for 
   591         * Create call handlers for call requests and for
   583         * monitoring call events.   
   592         * monitoring call events.
   584         */
   593         */
   585         void CreateCallHandlersL();
   594         void CreateCallHandlersL();
   586         
   595 
   587         /**
   596         /**
   588         * Update call state from ETel
   597         * Update call state from ETel
   589         * @return system wide error code 
   598         * @return system wide error code
   590         */
   599         */
   591         int UpdateCallState();
   600         int UpdateCallState();
   592         
   601 
   593         /**
   602         /**
   594          * Sends a remote party info changed notification
   603          * Sends a remote party info changed notification
   595          * if the remote party number has changed. 
   604          * if the remote party number has changed.
   596          */
   605          */
   597         void NotifyRemotePartyNumberChanged();
   606         void NotifyRemotePartyNumberChanged();
   598 
   607 
   599 	private: 
   608 	private:
   600 
   609 
   601         enum TCSPCallAudioStatus {
   610         enum TCSPCallAudioStatus {
   602             ECSPCallAudioStatusInactive,
   611             ECSPCallAudioStatusInactive,
   603             ECSPCallAudioStatusActive
   612             ECSPCallAudioStatusActive
   604             };
   613             };
   607 
   616 
   608           /**
   617           /**
   609           * CCP Call Observer array.
   618           * CCP Call Observer array.
   610           */
   619           */
   611           RPointerArray<MCCPCallObserver> iObservers;
   620           RPointerArray<MCCPCallObserver> iObservers;
   612           
   621 
   613           /**
   622           /**
   614           * Actual ETel call handle.
   623           * Actual ETel call handle.
   615           */
   624           */
   616           RMobileCall iCall;
   625           RMobileCall iCall;
   617 
   626 
   621           RMobileLine& iLine;
   630           RMobileLine& iLine;
   622 
   631 
   623           /**
   632           /**
   624           * Determines if the call direction is either MO (ETrue) or MT (EFalse)
   633           * Determines if the call direction is either MO (ETrue) or MT (EFalse)
   625           */
   634           */
   626           TBool iMobileOriginated;  
   635           TBool iMobileOriginated;
   627 
   636 
   628           /**
   637           /**
   629           * Name information of the call.
   638           * Name information of the call.
   630           * 
   639           *
   631           * Name information is stored during CSPCall construction
   640           * Name information is stored during CSPCall construction
   632           * and assigned to iCallName (MT or client call) or 
   641           * and assigned to iCallName (MT or client call) or
   633           * iRemotePartyNumber (MO call) afterwards.    
   642           * iRemotePartyNumber (MO call) afterwards.
   634           */
   643           */
   635           TBuf<KCSPPhoneNumberMaxLength> iName;
   644           TBuf<KCSPPhoneNumberMaxLength> iName;
   636           
   645 
   637           /**
   646           /**
   638           * Remote party name of the call.
   647           * Remote party name of the call.
   639           */
   648           */
   640           TBuf<KCSPPhoneNumberMaxLength> iRemotePartyNumber;
   649           TBuf<KCSPPhoneNumberMaxLength> iRemotePartyNumber;
   641           
   650 
   642           /**
   651           /**
   643           * Remote party name of the call.
   652           * Remote party name of the call.
   644           */
   653           */
   645           TBuf<KCSPCallingNameMaxLength> iRemotePartyName;
   654           TBuf<KCSPCallingNameMaxLength> iRemotePartyName;
   646 
   655 
   647           /**
   656           /**
   648           * Dialled party of the call.
   657           * Dialled party of the call.
   649           */
   658           */
   650           TBuf<KCSPPhoneNumberMaxLength> iDialledParty;
   659           TBuf<KCSPPhoneNumberMaxLength> iDialledParty;
   651           
   660 
   652           /**
   661           /**
   653           * Call name for MT call.
   662           * Call name for MT call.
   654           */
   663           */
   655           TName iCallName;
   664           TName iCallName;
   656 
   665 
   657           /**
   666           /**
   658           * Call parameters.
   667           * Call parameters.
   659           */      
   668           */
   660           CCCECallParameters* iParams; 
   669           CCCECallParameters* iParams;
   661          
   670 
   662           /**
   671           /**
   663           * Call state in CCP format
   672           * Call state in CCP format
   664           */
   673           */
   665           MCCPCallObserver::TCCPCallState iCallState;
   674           MCCPCallObserver::TCCPCallState iCallState;
   666           
   675 
   667           /**
   676           /**
   668           * Capability flags.
   677           * Capability flags.
   669           */
   678           */
   670           TUint32 iCapsFlags;
   679           TUint32 iCapsFlags;
   671 
   680 
   672           /**
   681           /**
   673           * Call status monitor
   682           * Call status monitor
   674           */
   683           */
   675           CSPEtelCallStatusMonitor* iCallStatusMonitor;
   684           CSPEtelCallStatusMonitor* iCallStatusMonitor;
   676             
   685 
   677           /**
   686           /**
   678           * Call event monitor
   687           * Call event monitor
   679           */
   688           */
   680           CSPEtelCallEventMonitor* iCallEventMonitor;
   689           CSPEtelCallEventMonitor* iCallEventMonitor;
   681           
   690 
   682           /**
   691           /**
   683           * Call info monitor
   692           * Call info monitor
   684           */
   693           */
   685           CSPCallInfoMonitor* iCallInfoMonitor;
   694           CSPCallInfoMonitor* iCallInfoMonitor;
   686           
   695 
   687           /**
   696           /**
   688           * Makes the asynchronic requests for various purposes.
   697           * Makes the asynchronic requests for various purposes.
   689           */
   698           */
   690           CSPEtelCallRequester* iRequester;
   699           CSPEtelCallRequester* iRequester;
   691 
   700 
   701 
   710 
   702           /**
   711           /**
   703           * Call termination error notification has been sent.
   712           * Call termination error notification has been sent.
   704           */
   713           */
   705           TBool iTerminationErrorNotified;
   714           TBool iTerminationErrorNotified;
   706           
   715 
   707           /**
   716           /**
   708           * Emergency call.
   717           * Emergency call.
   709           */
   718           */
   710           TBool iIsEmergencyCall;
   719           TBool iIsEmergencyCall;
   711     
   720 
   712     private:
   721     private:
   713         
   722 
   714           /**
   723           /**
   715           * Transfer provider.
   724           * Transfer provider.
   716           * Own.
   725           * Own.
   717           */
   726           */
   718           CSPTransferProvider* iTransferProvider;
   727           CSPTransferProvider* iTransferProvider;
   719           
   728 
   720           /**
   729           /**
   721           * Forward provider. No actual implementation.
   730           * Forward provider. No actual implementation.
   722           * Own.
   731           * Own.
   723           */          
   732           */
   724           CSPForwardProvider* iForwardProvider;
   733           CSPForwardProvider* iForwardProvider;
   725           
   734 
   726           /**
   735           /**
   727           * Audio dev sound handler.
   736           * Audio dev sound handler.
   728           * Not own.
   737           * Not own.
   729           */
   738           */
   730           CSPAudioHandler* iAudioHandler;
   739           CSPAudioHandlerBase* iAudioHandler;
   731           
   740 
   732           /**
   741           /**
   733           * FDN check usage status. Default is on. (ETrue)
   742           * FDN check usage status. Default is on. (ETrue)
   734           */
   743           */
   735           TBool iFdnCheck;          
   744           TBool iFdnCheck;
   736           
   745 
   737           /**
   746           /**
   738           * Monitors call capabilities from ETel.
   747           * Monitors call capabilities from ETel.
   739           * Own.
   748           * Own.
   740           */
   749           */
   741           CSPEtelCallCapsMonitor* iCallCapsMonitor;
   750           CSPEtelCallCapsMonitor* iCallCapsMonitor;
   742                     
   751 
   743           /*  
   752           /*
   744           * UUS monitor
   753           * UUS monitor
   745           */          
   754           */
   746           CSPUUIMonitor* iUUIMonitor;
   755           CSPUUIMonitor* iUUIMonitor;
   747           
   756 
   748           /*  
   757           /*
   749           * UUS sender
   758           * UUS sender
   750           */
   759           */
   751           CSPUUIMessageSender* iUUIMessageSender;
   760           CSPUUIMessageSender* iUUIMessageSender;
   752           
   761 
   753           /**
   762           /**
   754           * Data for parsed skype id.
   763           * Data for parsed skype id.
   755           * Own.
   764           * Own.
   756           */
   765           */
   757           HBufC* iSkypeId;
   766           HBufC* iSkypeId;
   758           
   767 
   759           /**
   768           /**
   760           * Audio stop requested status. The flag prevents double audio stop.
   769           * Audio stop requested status. The flag prevents double audio stop.
   761           * Stop is executed in Disconnecting state and Idle state 
   770           * Stop is executed in Disconnecting state and Idle state
   762           * if previous state has been DisconnectingWithInband.
   771           * if previous state has been DisconnectingWithInband.
   763           * Audio start status.
   772           * Audio start status.
   764           */
   773           */
   765           TCSPCallAudioStatus iAudioStatus;
   774           TCSPCallAudioStatus iAudioStatus;
   766           
   775 
   767           /**
   776           /**
   768           * Defines whether to report KErrGsmCCNormalUnspecified
   777           * Defines whether to report KErrGsmCCNormalUnspecified
   769           * and KErrGsmCCCallRejected.
   778           * and KErrGsmCCCallRejected.
   770           */
   779           */
   771           TBool iDontReportTerm;
   780           TBool iDontReportTerm;
   772           
   781 
   773           /**
   782           /**
   774            * User to user information. Sended to network before dial.
   783            * User to user information. Sended to network before dial.
   775            * Own.
   784            * Own.
   776            */
   785            */
   777           HBufC* iUserToUserInformation;
   786           HBufC* iUserToUserInformation;
   782            */
   791            */
   783           RMobileCall::TMobileCallInfoV7 iEtelCallInfo;
   792           RMobileCall::TMobileCallInfoV7 iEtelCallInfo;
   784           
   793           
   785           friend class UT_CSPCall;
   794           friend class UT_CSPCall;
   786           friend class MT_CConvergedCallProvider;
   795           friend class MT_CConvergedCallProvider;
   787           
   796 
   788           
       
   789     };
   797     };
   790 
   798 
   791 
       
   792 #endif // CSPCALL_H
   799 #endif // CSPCALL_H
       
   800