1 /**

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 * Declares dial up state classes.

    16 * 

    17 *

    18 */

    19 

    20 

    21 

    22 /**

    23  @file Nd_dlupstates.h

    24  @internalComponent

    25 */

    26 

    27 #ifndef __ND_DLUPSTATES_H__

    28 #define __ND_DLUPSTATES_H__

    29 

    30 

    31 #include "ND_DLUP.H"

    32 #include "Nd_dlinStates.h"

    33 #include "ND_SCR.H"

    34 

    35 class CDlUpInit : public CAgentStateBase

    36 /**

    37 Dial Up Init State.

    38 

    39 @internalComponent

    40 */

    41 	{

    42 public:

    43 	static CDlUpInit* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    44 	virtual ~CDlUpInit();

    45 	//CAgentStateBase Inheritance

    46 	virtual void StartState();

    47 	virtual CAgentStateBase* NextStateL(TBool aContinue);

    48 private:

    49 	CDlUpInit(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    50 	virtual void ConstructL();

    51 	virtual void DoCancel();

    52 	virtual void RunL();

    53 private:

    54 	MNetdialEnv* iNdEnv;

    55 	};

    56 

    57 class CDlUpDialling : public CAgentStateBase, public MNetDialEtelObserver

    58 /**

    59 Dial Up Dialling State.

    60 

    61 @internalComponent

    62 */

    63 	{

    64 public:

    65 	static CDlUpDialling* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    66 	virtual ~CDlUpDialling(); 

    67 	//CAgentStateBase Inheritance

    68 	virtual void StartState();

    69 	virtual CAgentStateBase* NextStateL(TBool aContinue);

    70 	//MNetDialEtelObserver Inheritance

    71 	virtual void TelFunctionComplete(TInt aError);

    72 private:

    73 	CDlUpDialling(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    74 	virtual void ConstructL();

    75 	virtual void DoCancel();

    76 	virtual void RunL();

    77 	virtual TInt RunError(TInt aError);

    78 private:

    79 	MNetdialEnv* iNdEnv;

    80 	};

    81 

    82 class CDlUpOpenDataPort : public CAgentStateBase

    83 /**

    84 Dial Up Open Data Port State.

    85 

    86 @internalComponent

    87 */

    88 	{

    89 public:

    90 	static CDlUpOpenDataPort* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    91 	virtual ~CDlUpOpenDataPort();

    92 	//CAgentStateBase Inheritance

    93 	virtual void StartState();

    94 	virtual CAgentStateBase* NextStateL(TBool aContinue);

    95 private:

    96 	CDlUpOpenDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

    97 	virtual void ConstructL();

    98 	virtual void DoCancel();

    99 	virtual void RunL();

   100 private:

   101 	MNetdialEnv* iNdEnv;

   102 	};

   103 

   104 class CDlUpScanScript : public CAgentStateBase, public MNetDialScriptObserver

   105 /**

   106 Dial Up Scan Script State.

   107 

   108 @internalComponent

   109 */

   110 	{

   111 public:

   112 	static CDlUpScanScript* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   113 	virtual ~CDlUpScanScript();

   114 	//CAgentStateBase Inheritance

   115 	virtual void StartState();

   116 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   117 	//MNetDialScriptObserver Inheritance

   118 	virtual void ScriptFunctionComplete(TInt aError);

   119 private:

   120 	CDlUpScanScript(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   121 	virtual void ConstructL();

   122 	virtual void DoCancel();

   123 	virtual void RunL();

   124 private:

   125 	MNetdialEnv* iNdEnv;

   126 	};

   127 

   128 class CDlUpGetLoginInfo : public CGetLoginInfo

   129 /**

   130 Dial Up Get Login Info State.

   131 

   132 @internalComponent

   133 */

   134 	{

   135 public:

   136 	static CDlUpGetLoginInfo* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   137 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   138 	~CDlUpGetLoginInfo();

   139 private:

   140 	CDlUpGetLoginInfo(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   141 	virtual void ConstructL();

   142 	};

   143 

   144 class CDlUpLogin : public CAgentStateBase, public MNetDialScriptObserver

   145 /**

   146 Dial Up Login State.

   147 

   148 @internalComponent

   149 */

   150 	{

   151 public:

   152 	static CDlUpLogin* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   153 	virtual ~CDlUpLogin();

   154 	//CAgentStateBase Inheritance

   155 	virtual void StartState();

   156 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   157 	void DoStartStateL();

   158 	//MNetDialScriptObserver Inheritance

   159 	virtual void ScriptFunctionComplete(TInt aError);

   160 private:

   161 	CDlUpLogin(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   162 	virtual void ConstructL();

   163 	virtual void DoCancel();

   164 	virtual void RunL();

   165 private:

   166 	MNetdialEnv* iNdEnv;

   167 	};

   168 

   169 class CDlUpCloseDataPort : public CAgentStateBase

   170 /**

   171 Dial Up Close Data Port State.

   172 

   173 @internalComponent

   174 */

   175 	{

   176 public:

   177 	static CDlUpCloseDataPort* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError);

   178 	virtual ~CDlUpCloseDataPort();

   179 	//CAgentStateBase Inheritance

   180 	virtual void StartState();

   181 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   182 	//MNetDialScriptObserver Inheritance

   183 private:

   184 	CDlUpCloseDataPort(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv, TInt aError);

   185 	virtual void ConstructL();

   186 	virtual void DoCancel();

   187 	virtual void RunL();

   188 private:

   189 	MNetdialEnv* iNdEnv;

   190 	TInt iError;

   191 	};

   192 

   193 #ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT

   194 class CDlUpOpen : public CNdCallBackStateBase, public MNetDialEtelObserver

   195 #else

   196 class CDlUpOpen : public CNdCallBackStateBase

   197 #endif

   198 /**

   199 Dial Up Open State.

   200 

   201 @internalComponent

   202 */

   203 	{

   204 public:

   205 	static CDlUpOpen* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   206 	virtual ~CDlUpOpen();

   207 	//CAgentStateBase Inheritance

   208 	virtual void StartState();

   209 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   210 #ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT	

   211 	//MNetDialEtelObserver Inheritance

   212 	virtual void TelFunctionComplete(TInt aError);

   213 #endif	

   214 private:

   215 	CDlUpOpen(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   216 	virtual void ConstructL();

   217 	virtual void DoCancel();

   218 	virtual void RunL();

   219 private:

   220 	MNetdialEnv* iNdEnv;

   221 #ifdef SYMBIAN_NETWORKING_CSDAGENT_BCA_SUPPORT

   222 	TBool iTelEvent:1;

   223 #endif	

   224 	};

   225 

   226 class CDlUpHangUp : public CNdCallBackStateBase, public MNetDialEtelObserver

   227 /**

   228 Dial Up HangUp State

   229 

   230 @internalComponent

   231 */

   232 	{

   233 public:

   234 	static CDlUpHangUp* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   235 	virtual ~CDlUpHangUp();

   236 	//CAgentStateBase Inheritance

   237 	virtual void StartState();

   238 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   239 	//MNetDialEtelObserver Inheritance

   240 	virtual void TelFunctionComplete(TInt aError);

   241 private:

   242 	CDlUpHangUp(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   243 	virtual void ConstructL();

   244 	virtual void DoCancel();

   245 	virtual void RunL();

   246 private:

   247 	MNetdialEnv* iNdEnv;

   248 	TBool iLogCallEnd ;

   249 	};

   250 

   251 class CDlUpDisconnect : public CNdCallBackStateBase

   252 /**

   253 Dial Up Disconnect State.

   254 

   255 @internalComponent

   256 */

   257 	{

   258 public:

   259 	static CDlUpDisconnect* NewL(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   260 	virtual ~CDlUpDisconnect();

   261 	//CAgentStateBase Inheritance

   262 	virtual void StartState();

   263 	virtual CAgentStateBase* NextStateL(TBool aContinue);

   264 private:

   265 	CDlUpDisconnect(MAgentStateMachineEnv& aSMObserver, MNetdialEnv& aNdEnv);

   266 	virtual void ConstructL();

   267 	virtual void DoCancel();

   268 	virtual void RunL();

   269 private:

   270 	MNetdialEnv* iNdEnv;

   271 	};

   272 

   273 #endif