--- /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 <et_phone.h>
+#include "utils.h"
+#include <etelmm.h>
+#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<CSimCall*>* 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__