diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/commontsy/inc/mmtsy/cmmcalltsy.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/commontsy/inc/mmtsy/cmmcalltsy.h Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,1479 @@ +/* +* Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + + +#ifndef CMMCALLTSY_H +#define CMMCALLTSY_H + +//INCLUDES +#include +#include +#include "MmTsy_timeoutdefs.h" +#include + +// FORWARD DECLARATIONS +class CMmPhoneTsy; +class CMmLineTsy; +class CMmCallExtInterface; +class CAcquireOwnerList; +class CHeartbeatRunner; +class CMmTsyReqHandleStore; +class CMmMessageManagerBase; +class CMmDataPackage; +class MTelephonyAudioControl; + +// CLASS DECLARATION + +/** + * CMmCallTsy contains extended call functionality that is not mode-dependent + */ +NONSHARABLE_CLASS( CMmCallTsy ) : public CCallBase + { + public: // Enumerations + + /**Enumeration for TSY request handle types*/ + enum TCallRequestTypes + { + EMultimodeCallReqHandleUnknown, //0 + EMultimodeCallNotifyStatusChange, + EMultimodeCallNotifyDurationChange, + EMultimodeCallCapsChangeNotification, + EMultimodeCallDial, + EMultimodeCallAnswer, //5 + EMultimodeCallHangUp, + EMultimodeMobileCallHold, + EMultimodeMobileCallResume, + EMultimodeMobileCallSwap, + EMultimodeCallNotifyMobileCallStatusChange, //10 + EMultimodeCallNotifyCallEvent, + EMultimodeCallNotifyRemotePartyInfoChange, + EMultimodeMobileCallDialEmergencyCall, + EMultimodeMobileCallDeflectCall, + EMultimodeCallNotifyMobileCallCapsChange, //15 + EMultimodeCallTransfer, + EMultimodeCallGoOneToOne, + EMultimodeCallNotifyDataCallCapsChange, + EMultimodeCallSetDynamicHscsdParams, + EMultimodeCallNotifyHscsdInfoChange, //20 + EMultimodeCallNotifyPrivacyConfirmation, //21 + EMultimodeCallDialISV, + EMultimodeCallAnswerISV, + EMultimodeCallActiveUUS, + EMultimodeCallReceiveUUI,//25 + EMultimodeCallDialNoFdnCheck, //26 + // NOTE!: Declare constant for those requests that need + // own request handle record in iTsyReqHandleStore above the + // following! + EMultimodeCallMaxNumOfRequests + }; + + /**Enumeration for Dial Cancel*/ + enum TDialCancelStatus + { + EDialCancelNotCalled, + EDialCancelCallCalled, + EDialCancelCustomCalled + }; + + public: // Constructors and destructor + + /** + * Destructor. + */ + virtual ~CMmCallTsy(); + + public: // New functions + + /** + * Returns pointer to the Phone object + * + * + * @return Pointer to the Phone object + */ + CMmPhoneTsy* Phone(); + + /** + * Returns Line object from which this call was opened. + * + * + * @return Pointer to the Line object + */ + CMmLineTsy* Line(); + + /** + * Returns currently active call extension + * + * + * @return CMmCallExtInterface* Pointer to the call extension + */ + CMmCallExtInterface* ActiveCallExtension(); + + /** + * Complete dial request + * + * + * @param aResult Result of the request + */ + virtual void CompleteDial( TInt aResult ); + + /** + * Complete hang up + * + * + * @param aResult Result of the request + */ + virtual void CompleteHangUp( TInt aResult ); + + /** + * Complete answering to the incoming call + * + * + * @param aResult Result of the request + */ + virtual void CompleteAnswerIncomingCall( TInt aResult ); + + /** + * Complete status change notification + * + * + * @param aResult Result of the request + * @param aDataPackage: new call status value + */ + virtual void CompleteNotifyStatusChange( TInt aResult, + CMmDataPackage* aDataPackage ) = 0; + + /** + * Complete mobile call information change notification + * + * + * @param aDataPackage: new call information + */ + void CompleteNotifyMobileCallInfoChange( + CMmDataPackage* aDataPackage ); + + /** + * This method completes NotifyRemotePartyInfoChange notification + * + * + */ + void CompleteNotifyRemotePartyInfoChange(); + + /** + * This method completes call event initiated by remote party + * + * + * @param aDataPackage: remote event + */ + void CompleteNotifyRemoteCallEvent( + const CMmDataPackage* aPackage ); + + /** + * Complete a NotifyMobileCallCapsChange method + * + * + * @param aErrorCode Error code + */ + void CompleteNotifyMobileCallCapsChange( TInt aErrorCode ); + + /** + * Complete call duration change notification + * + * + */ + void CompleteNotifyCallDurationChange(); + + /** + * This method completes privacy confirmation notification + * + * + * @param aStatus privacy value + */ + void CompleteNotifyPrivacyConfirmation( + RMobilePhone::TMobilePhonePrivacy aStatus ); + + /** + * Completes call transfering + * + * + * @param aErrorCode Error code + */ + void CompleteTransfer( TInt aErrorCode ); + + /** + * Fills current parameters of mobile call info + * + * + * @param aInfo Pointer to mobile call information + * @return TInt Return value to ETel server + */ + virtual TInt FillMobileCallInfo( TDes8* aInfo ); + + /** + * Fills current parameters of mobile call info + * + * + * @param aInfo Pointer to mobile call information + * @return TInt Return value to ETel server + */ + TInt FillMobileCallInfoDefaults( RMobileCall::TMobileCallInfoV1* aInfo ); + + + /** + * Get call name + * + * + * return Call name + */ + const TDesC& CallName() const; + + /** + * Get call ID + * + * + * @return Call Id + */ + TInt CallId() const; + + /** + * Set call ID + * + * + * @param aCallId Call ID + * @return Success/failure value. + */ + TInt SetCallId( TInt aCallId ); + + /** + * Set call Status + * + * + * @param aCallStatus: Core call status + * @param aMobileCallStatus: Call status + */ + void SetCallStatus( + RCall::TStatus aCallStatus, + RMobileCall::TMobileCallStatus aMobileCallStatus ); + + /** + * Returns call ID of the previous active call + * + * + * @return Call Id of the previous active call + */ + TInt PreviousCallId() const; + + /** + * Resets call ID of the previous active call + * + * + */ + void ResetPreviousCallId(); + + /** + * Get call mode + * + * + * return Call mode + */ + RMobilePhone::TMobileService CallMode() const; + + /** + * Returns call status. For use inside the TSY + * + * + * return Call core status + */ + RCall::TStatus Status() const; + + /** + * Returns mobile call status. For use inside the TSY + * + * + * @return Current mobile call status + */ + RMobileCall::TMobileCallStatus MobileCallStatus() const; + + /** + * Returns call direction + * + * + * return Call direction (MO/MT call) + */ + RMobileCall::TMobileCallDirection CallDirection() const; + + /** + * Sets call direction + * + * + * @param aCallDirection Call direction (MO/MT call) + * @return Success/failure value + */ + TInt SetCallDirection( + RMobileCall::TMobileCallDirection aCallDirection ); + + /** + * Returns call capabilities + * + * + * @return Call capabilities + */ + TUint32 CallCaps() const; + + /** + * Sets call capabilities + * + * + * @param Call capabilities + */ + void SetCallCaps( TUint32 aCallCaps ); + + /** + * Returns value or internal attribute iGhostCall + * + * + * @return Value of iGhostCall + */ + TBool GetGhostCall() const; + + /** + * Returns ETrue if this service is pending on this call object + * + * + * @param aReqType Type of request + * @return requested or not from this call object. + */ + TBool ServiceRequested( CMmCallTsy::TCallRequestTypes aReqType ); + + /** + * Sets a flag that indicates if this call is not created through ETel + * + * + * @param aValue Ghost call or not + */ + void SetGhostCall( TBool aValue ); + + /** + * Handles call status change indications of ghost calls + * + * + * @param aResult Result value of the status change + * @param aDataPackage Package containing new call status + */ + void HandleGhostCallStatusChange ( + TInt aResult, + CMmDataPackage* aDataPackage ); + + /** + * Sets the value of the attribute iDiagnosticOctet + * + * + * @param aDiagnosticOctect SS diagnostic octet value + */ + void SetDiagnostics ( TUint8 aDiagnosticOctet ); + + /** + * Returns value or internal attribute iDiagnosticOctect + * + * + * @return Value of iDiagnosticOctect + */ + TUint8 GetDiagnostics () const; + + /** + * Return ETrue if this type of request is requested by any of TSY's + * client + * + * + * @param aReqType Type of request + * @return Locally requested or not. + */ + TBool IsServiceLocallyRequested( CMmCallTsy::TCallRequestTypes aReqType ); + + /** + * Set flag that indicates if client has opened existing call object + * for incoming call or ghost call that is created using AT-commands. + * + * + * @param aIsUnownedGhostCall Is this unowned ghost call object + */ + void SetUnownedCallObjectFlag( TBool aIsUnownedCallObject ); + + /** + * Returns iUnownedCallObject boolean that indicates if client has + * opened existing call object for incoming call or ghost call that + * is created using AT-commands. + * + * + * @return Value of iUnownedGhostCall boolean + */ + TBool IsUnownedCallObject() const; + + /** + * Returns ETrue if this call was originated through ETel API + * + * + * @return Value of iEtelOriginated boolean + */ + TBool ETelOriginated() const; + + /** + * Returns ETrue if this call is part of a MO conference + * (does not apply to an externally controlled conference call) + * + * + * @return Value of iIsPartOfConference boolean + */ + TBool IsPartOfConference() const; + + /** + * Sets the flag indicating that this call is part of a MO conference + * (does not apply to an externally controlled conference call) + * + * + * @param Is call part of conference + */ + void SetPartOfConference( TBool aPartOfConference ); + + /** + * Completes DialNoFdnCheck request + * + * + * @param aResult Result of the request + */ + virtual void CompleteDialNoFdn( TInt aResult ); + + /** + * Sets Dialflag value indicating if call is in dialling state + * + * + * @param TBool is dial ongoing + */ + virtual void SetDialFlag( TBool aDialFlag ); + + /** + * Returns Dialflag value indicating if call is in dialling state + * + * + * @return is dial ongoing + */ + virtual TBool GetDialFlag(); + +#ifdef REQHANDLE_TIMER + /** + * Calls the appropriate complete method due timer expiration + * + * + * @param aReqHandleType TSY request handle type. + * @param aError Error value for completion + */ + virtual void Complete( TInt aReqHandleType, TInt aError ); +#endif + + /** + * UUI message received from the remote user, complete req + * + * @param aDataPackage Includes received UUI information + * @param aResult Result code + */ + void CompleteReceiveUUI( CMmDataPackage* aDataPackage, TInt aResult ); + + public: // Functions from base classes + + /** + * Opens a call object using given name + * + * @param aName Object name that should be opened + * @return Opened object + */ + virtual CTelObject* OpenNewObjectByNameL( const TDesC& /*aName*/ ); + + /** + * Opens a call object and gives it a name + * + * + * @param aName On return contains the name of opened object + * @return Opened object + */ + CTelObject* OpenNewObjectL( TDes& /*aNewName*/ ); + + /** + * TRAP's all CMmCallTsy related MM API requests in case that + * they fail. This method functions only as a centralized TRAP for the + * DoExtFuncL method that does the actual mapping of IPC number to + * TSY method call. + * + * + * @param aTsyReqHandle TSY request handle from ETel server + * @param aIpc IPC number of the request + * @param aPackage Reference to the input parameters. + * @return KErrNone/KErrNotSupported + */ + TInt ExtFunc( const TTsyReqHandle aTsyReqHandle, + const TInt aIpc, const TDataPackage& aPackage ); + + /** + * Returns request mode for given IPC number + * + * + * @param aIpc IPC number of the request + * @return Request mode + */ + virtual CTelObject::TReqMode ReqModeL( const TInt aIpc ) = 0; + + /** + * Returns number of slots to be used for a given IPC + * + * + * @param aIpc IPC number of the request + * @return Number of slots for this request + */ + virtual TInt NumberOfSlotsL( const TInt aIpc ) = 0; + + /** + * Cancels request that's IPC number and request handle are given as + * parameters + * + * + * @param aIpc: IPC number of the request + * @param aTsyReqHandle Request handle from ETel server + * @return KErrNone/KErrNotSupported + */ + virtual TInt CancelService( const TInt aIpc, + const TTsyReqHandle aTsyReqHandle ) = 0; + + /** + * Register given notification + * + * + * @param aIpc IPC number of the request + * @return Result of the request + */ + virtual TInt RegisterNotification( const TInt aIpc ) = 0; + + /** + * Deregister given notification + * + * + * @param aIpc IPC number of the request + * @return Result of the request + */ + virtual TInt DeregisterNotification( const TInt aIpc ) = 0; + + /** + * Transfers call ownership. + * + * + * @param aTsyReqHandle TSY request handle + * @return KErrNone + */ + virtual TInt TransferOwnership( + const TTsyReqHandle /*aTsyReqHandle*/ ); + + /** + * Acquires ownership. + * + * + * @param aTsyReqHandle TSY request handle + * @return KErrNone + */ + virtual TInt AcquireOwnership( + const TTsyReqHandle /*aTsyReqHandle*/ ); + + /** + * Cancels method for AcquireOwnership. + * + * + * @param aTsyReqHandle TSY request handle + * @return KErrNone + */ + virtual TInt AcquireOwnershipCancel( + const TTsyReqHandle /*aTsyReqHandle*/ ); + + /** + * Relinquishes ownership. + * + * + * @return KErrNone + */ + virtual TInt RelinquishOwnership(); + + /** + * Get call ownership status. + * + * + * @param aTsyReqHandle TSY request handle + * @param aOwnershipStatus Ownership status + * @return KErrNone + */ + virtual TInt GetOwnershipStatus( + const TTsyReqHandle /*aTsyReqHandle*/, + RCall::TOwnershipStatus* /*aOwnershipStatus*/ ); + + /** + * Notify when hook status has changed + * + * + * @param aTsyReqHandle TSY request handle + * @param aHookStatus Hook status + * @return Return value to the ETel Server + */ + TInt NotifyHookChange( const TTsyReqHandle aTsyReqHandle, + RCall::THookStatus* /*aHookStatus*/ ); + + /** + * Cancels hook status change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyHookChangeCancel( const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns the call status to the client + * + * + * @param aTsyReqHandle TSY request handle + * @param aStatus Current call status + * @return Return value to the ETel Server + */ + TInt GetStatus( const TTsyReqHandle aTsyReqHandle, + RCall::TStatus *aStatus ); + + /** + * Notify when the status of the call has changed + * + * + * @param aTsyReqHandle TSY request handle + * @param aStatus Contains Core call status on return + * @return Return value to the ETel Server + */ + TInt NotifyStatusChange( const TTsyReqHandle aTsyReqHandle, + RCall::TStatus* aStatus ); + + /** + * Cancels status change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyStatusChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns the call capabilities to the client + * + * + * @param aTsyReqHandle TSY request handle + * @param aCaps Contains call capabilities on return + * @return Return value to the ETel Server + */ + TInt GetCaps( const TTsyReqHandle aTsyReqHandle, + RCall::TCaps* aCaps ); + + /** + * Request for core caps change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @param aCaps Contains core call caps on return + * @return Return value to the ETel Server + */ + TInt NotifyCapsChange( const TTsyReqHandle aTsyReqHandle, + RCall::TCaps* aCaps ); + + /** + * Cancels core caps change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyCapsChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns call duration information to the client + * + * + * @param aTsyReqHandle TSY request handle + * @param aTime Current duration + * @return Return value to the ETel Server + */ + TInt GetCallDuration( const TTsyReqHandle aTsyReqHandle, + TTimeIntervalSeconds* aTime ); + + /** + * Notifies about changes in call duration + * + * + * @param aTsyReqHandle TSY request handle + * @param aTime On return contains current call duration + * @return Return value to the ETel Server + */ + TInt NotifyDurationChange( const TTsyReqHandle aTsyReqHandle, + TTimeIntervalSeconds* aTime ); + + /** + * Cancels duration change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyDurationChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns call parameters to the client + * + * + * @param aTsyReqHandle TSY request handle + * @param aParams Contains call parameters on return + * @return Return value to the ETel Server + */ + TInt GetCallParams( const TTsyReqHandle aTsyReqHandle, + TDes8* aParams ); + + /** + * Returns call information (core) to the client + * + * + * @param aTsyReqHandle TSY request handle + * @param aCallInfo Contains core call information on return + * @return Return value to the ETel Server + */ + TInt GetInfo( const TTsyReqHandle aTsyReqHandle, + RCall::TCallInfo* aCallInfo ); + + /** + * Dials a call. + * + * + * @param aTsyReqHandle Tsy request handle + * @param aCallParams Call parameters + * @param aTelNumber Phone number to be called + * @return KErrNone or KErrNotSupported + */ + virtual TInt Dial( const TTsyReqHandle aTsyReqHandle, + const TDesC8* aCallParams, TDesC* aTelNumber ) = 0; + + /** + * Cancels dialling. + * + * + * @param aTsyReqHandle Tsy request handle + * @return KErrNone, KErrNotSupported, KErrInUse or KErrGeneral + */ + virtual TInt DialCancel( const TTsyReqHandle aTsyReqHandle ); + + /** + * Answers to an incoming call + * + * + * @param aTsyReqHandle Request handle from the ETel server + * @param aCallParams Call parameters + * @return KErrNone/KErrNotSupported + */ + virtual TInt AnswerIncomingCall( const TTsyReqHandle aTsyReqHandle, + const TDesC8* aCallParams ) = 0; + + /** + * Cancels answering to an incoming call + * + * + * @param aTsyReqHandle Request handle from the ETel server + * @return KErrNone/KErrNotSupported + */ + virtual TInt AnswerIncomingCallCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Hangs up the call + * + * + * @param aTsyReqHandle Request handle from ETel server + * @return KErrNone/KErrNotSupported + */ + virtual TInt HangUp( const TTsyReqHandle aTsyReqHandle ) = 0; + + /** + * Cancels the hangup + * + * + * @param aTsyReqHandle Request handle from ETel server + * @return KErrNone/KErrNotSupported + */ + TInt HangUpCancel( const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns ETrue if this call is part of a MO conference and MT released + * (does not apply to an externally controlled conference call) + * + * + * @return Value of iIsRemoteReleasedCall boolean + */ + TBool IsRemoteReleasedCall() const; + +#ifdef TF_LOGGING_ENABLED + /** + * Overloads original ReqCompleted for logging purposes + * + * + * @param aTsyReqHandle TSY request handle + * @param aError error value + */ + virtual void ReqCompleted( const TTsyReqHandle aTsyReqHandle, + const TInt aError ); +#endif + + /** + * Returns fax settings to the client + * + * + * @param aTsyReqHandle TSY req handle + * @param TFaxSessionSettings Fax settings + * @return KErrNotSupported + */ + virtual TInt GetFaxSettings( + const TTsyReqHandle /*aTsyReqHandle*/, + RCall::TFaxSessionSettings* /*aSettings*/ ); + + /** + * Sets new fax settings + * + * + * @param aTsyReqHandle TSY req handle + * @param TFaxSessionSettings Fax settings + * @return KErrNotSupported + */ + virtual TInt SetFaxSettings( + const TTsyReqHandle /*aTsyReqHandle*/, + const RCall::TFaxSessionSettings* /*aSettings*/ ); + + /** + * Sets iExtensionId + * @param aExtensionId + */ + virtual void SetExtensionId( TInt aExtensionId ); + + /** + * Gets iExtensionId + * + * + * @return ExtensionId + */ + virtual TInt GetExtensionId(); + + /** + * Sets iDialTypeId + * + * @param aDialType + * + */ + virtual void SetDialTypeId( TUint8 aDialType ); + + /** + * Gets iDialTypeId + * + * + * @return iDialTypeId + */ + virtual TUint8 GetDialTypeId(); + + protected: // Constructors and destructor + + /** + * C++ default constructor. + */ + CMmCallTsy(); + + /** + * By default Symbian 2nd phase constructor is private. + * + * + * @param RMobilePhone::TMobileService aMode Call mode + */ + virtual void ConstructL( RMobilePhone::TMobileService aMode ); + + protected: // New functions + + /** + * Initialises extension modules + * + * + * @param RMobilePhone::TMobileService Call mode + */ + virtual void InitExtensionModulesL( RMobilePhone::TMobileService aMode ); + + /** + * Initialises miscellaneous internal attributes + * + * + */ + virtual void InitInternalAttributes(); + + /** + * DoExtFuncL is called by the server when it has a "extended", + * i.e. non-core ETel request for the TSY. To process a request handle, + * request type and request data are passed to the TSY. + * + * + * @param aTsyReqHandle Request handle from ETel server + * @param aIpc IPC number of the request + * @param aPackage Reference to the input parameters. + * @return KErrNone/KErrNotSupported + */ + virtual TInt DoExtFuncL( const TTsyReqHandle aTsyReqHandle, const TInt aIpc, + const TDataPackage& aPackage ) = 0; + + /** + * Returns pointer to iTsyReqHandleStore + * + * + * @return CMmTsyReqHandleStore* Pointer to the TsyReqHandleStore + */ + CMmTsyReqHandleStore* GetCallReqHandleStore(); + + /** + * Completes caps change notification + * + * + */ + void CompleteNotifyCapsChange(); + + /** + * Complete call event notification + * + * + * @param event that has occurred + */ + void CompleteNotifyCallEvent( RMobileCall::TMobileCallEvent aEvent ); + + /** + * Returns the call control and call event capabilities + * + * + * @param aTsyReqHandle TSY request handle + * @param aCaps Contains mobile call capabilities on return + * @return Return value to the ETel Server + */ + TInt GetMobileCallCaps( const TTsyReqHandle aTsyReqHandle, + TDes8* aCaps ); + + /** + * Notifies change of mobile call capabilities + * + * + * @param aCaps Contains mobile call capabilities on return + * @return Return value to the ETel Server + */ + TInt NotifyMobileCallCapsChange( TDes8* aCaps ); + + /** + * Cancels NotifyMobileCallCapsChange method + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyMobileCallCapsChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Transfer a call to a remote party with out answering the call + * + * + * @param aTsyReqHandle TSY request handle + * @return KErrNone + */ + TInt TransferL( const TTsyReqHandle aTsyReqHandle ); + + /** + * Set call name + * + * + * @param aCallName New call name + */ + void SetCallName( const TName& aCallName ); + + /** + * Requests notifications of privacy status changes + * + * + * @param aPrivacyStatus* Current privacy status + * @return Return value to ETel server + */ + TInt NotifyPrivacyConfirmation ( + RMobilePhone::TMobilePhonePrivacy* aPrivacyStatus ); + + /** + * Cancels privacy status change notifications + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to ETel server + */ + TInt NotifyPrivacyConfirmationCancel ( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Returns the current status of the call through the aStatus argument + * + * + * @param aTsyReqHandle TSY request handle + * @param aStatus Contains mobile call status on return + * @return Return value to the ETel Server + */ + TInt GetMobileCallStatus( const TTsyReqHandle aTsyReqHandle, + RMobileCall::TMobileCallStatus* aStatus ); + + /** + * Allows a client to be notified when the mobile call changes state. + * + * + * @param aStatus Contains mobile call status on return + * @return Return value to the ETel Server + */ + TInt NotifyMobileCallStatusChange( + RMobileCall::TMobileCallStatus* aStatus ); + + /** + * Cancels an outstanding asynchronous NotifyMobileCallStatusChange + * request. + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyMobileCallStatusChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Allows clients to be notified when various call events occur. + * + * + * @param aEvent Contains call event on return + * @return Return value to the ETel Server + */ + TInt NotifyCallEvent( RMobileCall::TMobileCallEvent* aEvent ); + + /** + * This method cancels an outstanding asynchronous NotifyCallEvent + * request. + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyCallEventCancel( const TTsyReqHandle aTsyReqHandle ); + + /** + * The method returns current values of the call information + * + * + * @param aTsyReqHandle TSY request handle + * @param aInfo Contains mobile call info on return + * @return Return value to the ETel Server + */ + TInt GetMobileCallInfo( const TTsyReqHandle aTsyReqHandle, + TDes8* aInfo ); + + /** + * Allows the client to be notified of any change in the remote party + * information. + * + * + * @param aRemotePartyInfo Contains remote party information on return + * @return Return value to the ETel Server + */ + TInt NotifyRemotePartyInfoChange( TDes8* aRemotePartyInfo ); + + /** + * This method cancels an outstanding asynchronous + * NotifyRemotePartyInfoChange request. + * + * + * @param aTsyReqHandle TSY request handle + * @return Return value to the ETel Server + */ + TInt NotifyRemotePartyInfoChangeCancel( + const TTsyReqHandle aTsyReqHandle ); + + /** + * Resets the status of the call + * + * + */ + virtual void ClearCallStatus(); + + /** + * Set previous active call ID + * + * + * @param TInt Call id of the previous active call + */ + void SetPreviousCallId( TInt aCurrentId ); + + /** + * Returns call duration in seconds + * + * + * @return Call duration in seconds + */ + TTimeIntervalSeconds GetCallDurationInSeconds(); + +#ifdef REQHANDLE_TIMER + /** + * Chooses the type of response, automatic or common + * + * + * @param aReqHandleType TSY request handle type. + * @param aTsyReqHandle TSY request handle to be stored. + */ + virtual void SetTypeOfResponse( const TInt aReqHandleType, + const TTsyReqHandle aTsyReqHandle ) = 0; +#endif + + /** + * Specifies which User-To-User Signalling service(s) + * the phone should request to activate. + * + * @param aUUSRequest Pointer to client side data + * @return Return value to the ETel Server + */ + TInt ActivateUUS( const TTsyReqHandle aTsyReqHandle, + RMobileCall::TMobileCallUUSRequestV1Pckg* aUUSRequest ); + + /** + * Enables the client to receive the next incoming + * UUI message from the remote user. + * + * @param aTsyReqHandle TSY request handle, + * @param aUUI Pointer to client side data + * @return Return value to the ETel Server + */ + TInt ReceiveUUI( const TTsyReqHandle aTsyReqHandle, + RMobileCall::TMobileCallUUI* aUUI ); + + /** + * Cancels an outstanding EMobileCallReceiveUUI request + * + * @param aTsyReqHandle TSY request handle, complete with KErrCancel + * @return KErrNone + */ + TInt ReceiveUUICancel( const TTsyReqHandle aTsyReqHandle ); + + /** + * Updates life time call duration with remaining call duration + * + */ + void UpdateLifeTimer(); + + private: + /** + * Checks wether or not a ETel request can be performed while + * offline mode is enabled + * + * + * @param aIpc Ipc number of the request + * @return Is request possible in offline mode + */ + TBool IsRequestPossibleInOffline( TInt aIpc ) const; + + protected: // Data + + /** + * A pointer to the multimode line object + * Own. + */ + CMmLineTsy* iMmLine; + + /** + * A pointer to external call interface object + * Own. + */ + CMmCallExtInterface* iMmCallExtInterface; + + /** + * A pointer to multimode phone object + * Own. + */ + CMmPhoneTsy* iMmPhone; + + /** + * Pointer to request handle store + * Own. + */ + CMmTsyReqHandleStore* iTsyReqHandleStore; + + /** + * A table for call request handles + */ + TTsyReqHandle iCallReqHandles[EMultimodeCallMaxNumOfRequests]; + + /** + * Call mode + */ + RMobilePhone::TMobileService iCallMode; + + /** + * Pointer to the message manager + * Own. + */ + CMmMessageManagerBase* iMessageManager; + + /** + * Call status + */ + RCall::TStatus iCallStatus; + + /** + * Call ID, used for communication between TSY and call server + */ + TInt iCallId; + + /** + * Last active Call ID, the call id is reset when call goes + * to idle state + */ + TInt iPreviousCallId; + + /** + * Dynamic Call caps + */ + RCall::TCaps iCallCaps; + + /** + * Call name + */ + TName iCallName; + + /** + * Mobile call parameters + */ + RMobileCall::TMobileCallParamsV7 iCallParams; + + /** + * Mobile call parameters package + */ + RMobileCall::TMobileCallParamsV1Pckg iCallParamsPckg; + + /** + * Contains the reason for the call termination + */ + TInt iLastExitCode; + + /** + * Duration change notifier + */ + CHeartbeatRunner* iCallTimer; + + /** + * Current Mobile Call status + */ + RMobileCall::TMobileCallStatus iMobileCallStatus; + + /** + * Call direction + */ + RMobileCall::TMobileCallDirection iCallDirection; + + /** + * Status of dialCancel + */ + TDialCancelStatus iDialCancelFlag; + + /** + * Status of AnswerIncomingCallCancel + */ + TBool iAnswerCancelFlag; + + /** + * Request handle type + */ + TCallRequestTypes iReqHandleType; + + /** + * diagnostic Octets + */ + TUint8 iDiagnosticOctet; + + /** + * Boolean that indicates is this unowned call object + */ + TBool iUnownedCallObject; + + /** + * Boolean that indicates is this ghost call + * (created using AT-commands) + */ + TBool iGhostCall; + + /** + * Previous call capabilities. Used to determine if notification + * about capabilities change should be sent + */ + RCall::TCaps iPreviousCaps; + + /** + * Previous call control capabilities. + */ + TUint32 iPreviousCallControlCaps; + + /** + * Pointer to Notify Mobile Call capabilities (pointing to ETel + * server's address space) + * Own. + */ + TDes8* iRetNotifyMobileCallCaps; + + /** + * Pointer to the core call capabilities (pointing to ETel server's + * address space) + * Own. + */ + RCall::TCaps* iRetCaps; + + /** + * Pointer to the core call status (pointing to ETel server's address + * space) + */ + RCall::TStatus* iRetStatus; + + /** + * Pointer to the mobile call status (pointing to ETel server's address + * space) + * Own. + */ + RMobileCall::TMobileCallStatus* iRetMobileCallStatus; + + /** + * Pointer to the mobile remote party info (pointing to ETel server's + * address space) + * Own. + */ + TDes8* iRetRemotePartyInfo; + + /** + * Pointer to the call duration (pointing to ETel server's address + * space) + * Own. + */ + TTimeIntervalSeconds* iRetTimeIntervalSeconds; + + /** + * Pointer to the mobile call event (pointing to ETel server's address + * space) + * Own. + */ + RMobileCall::TMobileCallEvent* iRetCallEvent; + + /** + * Pointer to privacy confirmation status (pointing to ETel server's + * address space) + * Own. + */ + RMobilePhone::TMobilePhonePrivacy* iRetPrivacyStatus; + + /** + * Call ownership list + * Own. + */ + CAcquireOwnerList* iList; + + /** + * Is this an emergency call + */ + TBool iEmergencyCall; + + /** + * Is this call originated through ETel API + */ + TBool iEtelOriginated; + + /** + * Boolean that indicates if this call is part of a MO conference call + * (false if part of an externally controlled conference call) + */ + TBool iIsPartOfConference; + + /** + * Specify the ExtensionId + */ + TInt iExtensionId; + + /** + * Boolean indicating if dial is ongoing + */ + TBool iDialFlag; + + /** + * Boolean that indicates if this call is MT released + * and part of internally controlled conference call + */ + TBool iIsRemoteReleasedCall; + + /** + * Boolean indicating if the hangUp is ongoing + */ + TBool iHangUpFlag; + + /** + * Pointer to the UUI message (pointing to ETel server's address + * space) + * Not own. + */ + RMobileCall::TMobileCallUUI* iRetUUI; + + /** + * Buffer the incoming UUI information. This is only used with the + * UUS1 case, to be able to get the first complete data from LTSY. + */ + RMobileCall::TMobileCallUUI iReceivedUUI; + + /** + * Buffer the ActivateUUS request, + * send the infromation to LTSY during the dial (UUS1). + */ + RMobileCall::TMobileCallUUSRequestV1 iUUSRequest; + + /** + * Specify the dial type + */ + TUint8 iDialTypeId; + + /** + * Pointer to the telephony audio control + */ + MTelephonyAudioControl* iTelephonyAudioControl; + + /** + * Boolean that indicates if TelephonyAudioControl is set up or not. + * True if call routing control has been set up for the call. + * False when call is not set up (idle). + */ + TBool iTelephonyAudioControlSetup; + + }; + +#endif // CMMCALLTSY_H + +// End of File +