1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #ifndef __TE_ETELISVCALLFUNC_H_

    18 #define __TE_ETELISVCALLFUNC_H_

    19 

    20 class TTestCallParams 

    21 	{

    22 public:

    23 	CTelephony::TPhoneLine iLine;

    24 	CTelephony::TCallParamsV1Pckg* iCallParamsV1Pckg;

    25 	CTelephony::TTelAddress iTelAddress;

    26 	TRequestStatus iExpStat;

    27 	TInt iExpAPIErr;

    28 	CTelephony::TCallId iCallId; 

    29 	};

    30 

    31 class CTestDialNewCall : public CEtelIsvTestStep

    32 	{

    33 public:

    34 	CTestDialNewCall() ;

    35 	~CTestDialNewCall(){} ;

    36 	virtual enum TVerdict doTestStepL();

    37 	};

    38 

    39 class MActionParent;	

    40 class CTestDialNewCallAct : public CEtelIsvActBase

    41 	{

    42 public:	// functions

    43 	static CTestDialNewCallAct* NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony, TBool aUseMacros = ETrue);

    44 	static CTestDialNewCallAct* NewL(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent);

    45 	void ConstructL(); 

    46 	~CTestDialNewCallAct();

    47 	void TestDialNewCall(TTestCallParams& aTestCallParams, TBool aCheckConcurrency = EFalse);

    48 	void DoCancel();

    49 	void RunL();

    50 protected:

    51 	CTestDialNewCallAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent, TBool aUseMacros);

    52 private:	// data

    53 	TTestCallParams* iTestCallParams;

    54 	MActionParent* iParent;

    55 	TBool iUseMacros;

    56 	

    57 	TPckgBuf<CTelephony::TCallParamsV1> iCallParamsBuff;

    58 	};

    59 

    60 class CTestAnswerIncomingCall : public CEtelIsvTestStep

    61 	{

    62 public:

    63 	CTestAnswerIncomingCall(TInt& aCallCount) ;

    64 	~CTestAnswerIncomingCall(){} ;

    65 	virtual enum TVerdict doTestStepL();

    66 private:

    67 	TInt& iCallCount;

    68 	};

    69 	

    70 	

    71 class CTestAnswerIncomingCallAct : public CEtelIsvActBase

    72 	{

    73 public:	// functions

    74 	static CTestAnswerIncomingCallAct* NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony);

    75 	static CTestAnswerIncomingCallAct* NewL(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent);

    76 	void ConstructL(); 

    77 	~CTestAnswerIncomingCallAct();

    78 	void TestAnswerIncomingCall(TTestCallParams& aTestCallParams, TBool aCheckConcurrency = EFalse); 

    79 	void DoCancel();

    80 	void RunL();

    81 protected:

    82 	CTestAnswerIncomingCallAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent);

    83 private:	// data

    84 	TTestCallParams* iTestCallParams;

    85 	MActionParent* iParent; 

    86 	};

    87 	

    88 class CTestHold : public CEtelIsvTestStep

    89 	{

    90 public:

    91 	CTestHold() ;

    92 	~CTestHold(){} ;

    93 	virtual enum TVerdict doTestStepL();

    94 	};

    95 	

    96 class CTestHoldAct : public CEtelIsvActBase

    97 	{

    98 public:	// functions

    99 	static CTestHoldAct*  NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony);

   100 	void ConstructL(); 

   101 	~CTestHoldAct();

   102 	void TestHold(TTestCallParams& aTestCallParams, TBool aCheckConcurrency = EFalse);

   103 	void DoCancel();

   104 	void RunL();

   105 protected:

   106 	CTestHoldAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony);

   107 private:	// data

   108 	CTelephony::TCallId iCallId;

   109 	};

   110 	

   111 class CTestResume : public CEtelIsvTestStep

   112 	{

   113 public:

   114 	CTestResume() ;

   115 	~CTestResume(){} ;

   116 	virtual enum TVerdict doTestStepL();

   117 	};

   118 	

   119 class CTestResumeAct : public CEtelIsvActBase

   120 	{

   121 public:	// functions

   122 	static CTestResumeAct* NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony);

   123 	void ConstructL(); 

   124 	~CTestResumeAct();

   125 	void TestResume(TTestCallParams& aTestCallParams, TBool aCheckConcurrency = EFalse);

   126 	void DoCancel();

   127 	void RunL();

   128 protected:

   129 	CTestResumeAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony);

   130 private:	// data

   131 	CTelephony::TCallId iCallId; 

   132 	};

   133 	

   134 class CTestSwap : public CEtelIsvTestStep

   135 	{

   136 public:

   137 	CTestSwap() ;

   138 	~CTestSwap(){} ;

   139 	virtual enum TVerdict doTestStepL();

   140 	};

   141 	

   142 class CTestSwapAct : public CEtelIsvActBase

   143 	{

   144 public:	// functions

   145 	static CTestSwapAct* NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony);

   146 	void ConstructL(); 

   147 	~CTestSwapAct();

   148 	void TestSwap(TTestCallParams& aTestCallParams1, TTestCallParams& aTestCallParams2, TBool aCheckConcurrency = EFalse);        

   149 	void DoCancel();

   150 	void RunL();

   151 protected:

   152 	CTestSwapAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony);

   153 private:	// data

   154 	CTelephony::TCallId* iCallId1; 

   155 	CTelephony::TCallId* iCallId2; 

   156 	};

   157 	

   158 class CTestHangup : public CEtelIsvTestStep

   159 	{

   160 public:

   161 	CTestHangup() ;

   162 	~CTestHangup(){} ;

   163 	virtual enum TVerdict doTestStepL();

   164 	};

   165 	

   166 class CTestHangupAct : public CEtelIsvActBase

   167 	{

   168 public:	// functions

   169 	static CTestHangupAct* NewLC(CEtelIsvTestStep* aTestStep,CTelephony* aTelephony, TBool aUseMacros = ETrue);

   170 	static CTestHangupAct* NewL(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent);

   171 	void ConstructL(); 

   172 	~CTestHangupAct();

   173 	void TestHangup(TTestCallParams& aTestCallParams, TBool aCheckConcurrency = EFalse);

   174 	void DoCancel();

   175 	void RunL();

   176 protected:

   177 	CTestHangupAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent, TBool aUseMacros);

   178 private:	// data

   179 	TTestCallParams* iTestCallParams;

   180 	MActionParent* iParent;

   181 	TBool iUseMacros;

   182 	};

   183 	

   184 class CTestHoldResume2Calls : public CEtelIsvTestStep

   185 	{

   186 public:

   187 	CTestHoldResume2Calls() ;

   188 	~CTestHoldResume2Calls(){} ;

   189 	virtual enum TVerdict doTestStepL();

   190 	//TInt maxCallStates;

   191 	};

   192 	

   193 class CTestGetCallDynamicCaps : public CEtelIsvTestStep	//test GetCallDynamicCaps()

   194 	{

   195 public:

   196 	CTestGetCallDynamicCaps() ;

   197 	~CTestGetCallDynamicCaps(){} ;

   198 	virtual enum TVerdict doTestStepL();

   199 	};

   200 

   201 class CTestCallFuncFlightModeOnWithPublishSubscribe : public CEtelIsvTestStep

   202 	{

   203 public:

   204 	CTestCallFuncFlightModeOnWithPublishSubscribe(TInt& aCallCount) ;

   205 	~CTestCallFuncFlightModeOnWithPublishSubscribe(){} ;

   206 	virtual enum TVerdict doTestStepL();

   207 	

   208 private:

   209 	TInt& iCallCount;

   210 	};

   211 

   212 class CTestDeprecatedDataCallAPIs : public CEtelIsvTestStep

   213 	{

   214 public:

   215 	CTestDeprecatedDataCallAPIs();

   216 	virtual enum TVerdict doTestStepL();

   217 	};

   218 

   219 #endif