diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/inc/CSimLine.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simtsy/inc/CSimLine.h Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,203 @@ +// Copyright (c) 2003-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 __CSIMLINE_H__ +#define __CSIMLINE_H__ + + +#include +#include "utils.h" +#include +#include "CSimPubSub.h" +#include "csimtimer.h" + +/** + * @file + * Declares the base class for voice and data lines - CSimLine + * @internalAll + */ + +const RMobileCall::TMobileCallStatus KStateTableTerminator=(RMobileCall::TMobileCallStatus)999; + +struct TStateChangeValidity + { + RMobileCall::TMobileCallStatus iOldState; + RMobileCall::TMobileCallStatus iNewState; + TInt iError; + }; + +/** + * This table is used to test the validity of potential line state changes. + * If the state change is not included in the table, the error KErrGeneral will be generated. + * A potential error value is included as the third item in each entry to enable errors + * other than KErrGeneral to be generated for specific erroneous state changes. + */ +const struct TStateChangeValidity KLineStateChangeValidity[]= { + { RMobileCall::EStatusIdle, RMobileCall::EStatusDialling, KErrNone }, + { RMobileCall::EStatusDialling, RMobileCall::EStatusConnecting, KErrNone }, + { RMobileCall::EStatusConnecting, RMobileCall::EStatusConnected, KErrNone }, + + { RMobileCall::EStatusIdle, RMobileCall::EStatusAnswering, KErrNone }, + { RMobileCall::EStatusIdle, RMobileCall::EStatusRinging, KErrNone }, + { RMobileCall::EStatusRinging, RMobileCall::EStatusAnswering, KErrNone }, + { RMobileCall::EStatusRinging, RMobileCall::EStatusRinging, KErrNone }, + { RMobileCall::EStatusRinging, RMobileCall::EStatusHold, KErrNone }, + { RMobileCall::EStatusAnswering, RMobileCall::EStatusConnected, KErrNone }, + + { RMobileCall::EStatusConnected, RMobileCall::EStatusHold, KErrNone }, + { RMobileCall::EStatusHold, RMobileCall::EStatusConnected, KErrNone }, + { RMobileCall::EStatusHold, RMobileCall::EStatusDialling, KErrNone }, + { RMobileCall::EStatusHold, RMobileCall::EStatusAnswering, KErrNone }, + { RMobileCall::EStatusHold, RMobileCall::EStatusDisconnecting, KErrNone }, + + { RMobileCall::EStatusConnected, RMobileCall::EStatusDisconnecting, KErrNone }, + { RMobileCall::EStatusConnected, RMobileCall::EStatusRinging, KErrNone }, // new AA + { RMobileCall::EStatusHold, RMobileCall::EStatusRinging, KErrNone }, + { RMobileCall::EStatusDisconnecting, RMobileCall::EStatusIdle, KErrNone }, + + { RMobileCall::EStatusDisconnecting, RMobileCall::EStatusConnected, KErrNone },//HangUp Cancel + + { KStateTableTerminator, KStateTableTerminator, KStateTableTerminator} + }; + +// +// CSimLine - General Line Functionality +// +/** +* This class 'CSimLine' is the Line class for the Simulator TSY. +* It is the base class for Voice (CSimVoiceLine) and Data (CSimDataLine) lines. +* It is an abstract class and is therefore not going to be instantiated. +* It will handle all functionality common to voice and data lines. +*/ +class CSimPhone; +class CSimCall; +class CTestConfigSection; + +class CSimLine : public CLineBase, public MPSSimObserver, public MTimerCallBack + { + friend class CSimVoiceCall; +public: + CSimLine(CSimPhone* aPhone); + ~CSimLine(); + virtual TInt RegisterNotification(const TInt aIpc); + virtual TInt DeregisterNotification(const TInt aIpc); + static void CloseLine(TAny* aObj); + virtual CTelObject::TReqMode ReqModeL(const TInt aIpc); + // MTelObjectTSY pure virtuals + virtual void Init(); + + // Functionality associated with the ETel Core API + virtual TInt GetInfo(const TTsyReqHandle aTsyReqHandle,RLine::TLineInfo* aLineInfo); + + virtual TInt GetCaps(const TTsyReqHandle aTsyReqHandle,RLine::TCaps* aCaps); + virtual TInt NotifyCapsChange(const TTsyReqHandle aTsyReqHandle, RLine::TCaps* aCaps); + virtual TInt NotifyCapsChangeCancel(const TTsyReqHandle aTsyReqHandle); + + virtual TInt NotifyIncomingCall(const TTsyReqHandle aTsyReqHandle, TName* aName); + virtual TInt NotifyIncomingCallCancel(const TTsyReqHandle aTsyReqHandle); + + virtual TInt NotifyHookChange(const TTsyReqHandle aTsyReqHandle, RCall::THookStatus* aHookStatus); + virtual TInt NotifyHookChangeCancel(const TTsyReqHandle aTsyReqHandle); + + virtual TInt GetStatus(const TTsyReqHandle aTsyReqHandle,RCall::TStatus* aStatus); + virtual TInt GetHookStatus(const TTsyReqHandle aTsyReqHandle,RMobileCall::THookStatus* aHookStatus); + virtual TInt NotifyStatusChange(const TTsyReqHandle aTsyReqHandle,RCall::TStatus* aLineStatus); + virtual TInt NotifyStatusChangeCancel(const TTsyReqHandle aTsyReqHandle); + + // Functionality associated with the ETel Multimode API + virtual TInt NotifyMobileLineStatusChange(const TTsyReqHandle aTsyReqHandle,RMobileCall::TMobileCallStatus* aLineStatus); + virtual TInt NotifyMobileLineStatusChangeCancel(const TTsyReqHandle aTsyReqHandle); + virtual TInt NotifyCallAdded(const TTsyReqHandle aTsyReqHandle,TName* aName); + virtual TInt NotifyCallAddedCancel(const TTsyReqHandle aTsyReqHandle); + virtual TInt GetMobileLineStatus(const TTsyReqHandle aTsyReqHandle,RMobileCall::TMobileCallStatus* aStatus); + virtual TInt NumberOfSlotsL(const TInt aIpc); + + const CTestConfigSection* CfgFile(); // < Accessor function for the configuration file. + TInt ChangeStateL(RMobileCall::TMobileCallStatus aNewState,TBool aSwap,CSimCall* aOriginatingCall); // < Attempt to change the line state. + virtual void SimPSEvent(const CSimPubSub::TPubSubProperty aProperty, TInt aStatus); // < MPSSimObserver pure virtual + TInt SetAutoAnswerCallObject(CSimCall* aCallObject); // < Set the call object that will be used to answer the next incoming call. + void ResetAutoAnswerCallObject(CSimCall* aCallObject); // < Reset the call object that would have been used to answer the next incoming call. + TInt SetRemoteHangupCallObject(CSimCall* aCallObject); // < Set the call object that will be remotely hung up. + void ResetRemoteHangupCallObject(CSimCall* aCallObject); // < Reset the call object that would have been remotely hung up. + void CallDestructor(CSimCall* aCall); + TBool IsAnswerCallObjectSpare(); + virtual TUint Caps()=0; + enum TCallType + { + ECallTypeSpareCall, + ECallTypeNormalCall + }; + virtual CSimCall* CreateNewCallL(TDes& aNewName,TCallType aCallType)=0; + virtual TInt FindActiveCall(CSimCall*& aCall)=0; + + + // Implement the MTimerCallBack interface + void TimerCallBack(TInt /*aId*/); + +protected: + void ConstructL(const TName& aName); + void HandleNewCallAddedNotification(const TDesC& aNewName); + +private: + void ProcessIncomingCallEvent(); + void ProcessNotifyIncomingCallEvent(); + void ProcessRemoteHangupEvent(); + RCall::TStatus GetCoreLineStatus(); //< Converts Multimode Line status to Core line status + +public: + CSimPhone* iPhone; //< Pointer to the phone object + TName iLineName; //< Current Line name + RMobileCall::TMobileCallStatus iState; //< Holds the current line status + void UpdatePhoneNotifiers(CSimCall*,TUint); + +protected: + CArrayFixFlat* iCalls; //< Array of all the call objects created + TInt iCallCnt; + TInt iNameIndex; //< Call index in the pool of calls created + TName iNameOfLastCallAdded; //< Name of last call added + CSimCall* iAnswerNextIncomingCall; //< Pointer for handling AnswerIncomingCall request + CSimCall* iSpareCall; //< Pointer to the spare call, used for incoming calls if none is allocated. + CSimCall* iRemoteHangupCall; //< Pointer for handling RemoteHangupCall request + + CSimPubSub::TPubSubProperty iICProperty; + CSimPubSub::TPubSubProperty iRHProperty; + + TBool iAnswerIncomingCallReqPending; //< There is an answer incoming call request pending on a call on this line. + TBool iRemoteHangupCallReqPending; //< There is a remote hangup call request pending on a call on this line. + + TNotifyData iNotifyMobileStatusChange; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for the mobile line status + TNotifyData iNotifyStatusChange; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for the line status + RCall::THookStatus iHookState; //< The current line hook state. + TNotifyData iNotifyHookChange; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for the line hook status + TNotifyData iNotifyCallAdded; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for the newly added call + TNotifyData iNotifyIncomingCall; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for IncomingCall Notification + TNotifyData iNotifyCapsChange; //< Holds the notification data (a flag, TsyReqHandle and any raw data) for Line Capability Notifications + TUint iCaps; //< Current line capability information +private: + CSimPubSub* iSimPubSubIC; //< Pointer to the Publish & Subscribe object for the incoming call + CSimPubSub* iSimPubSubRH; //< Pointer to the Publish & Subscribe object for the incoming call + + /** + Duration between receiving an incoming call and sending the + incoming call notification. + */ + TInt iNotifyIncomingCallPause; + /** + Timer to delay sending the notification of the incoming call. + */ + CSimTimer* iTimer; + }; + +#endif // __CSIMLINE_H__