1 // Copyright (c) 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 // @file atchld.h

    15 // This contains CATChld which hold, resume, release, swap one call.

    16 // 

    17 

    18 #ifndef ATCHLD_H_

    19 #define ATCHLD_H_

    20 

    21 //system include

    22 

    23 //user include

    24 #include "atcommandbase.h"

    25 

    26 class CATChld : public CAtCommandBase

    27 	{

    28 public:

    29 	

    30 	/**

    31 	*  static NewL  

    32 	*

    33 	* @param aGloblePhone

    34 	* @param aCtsyDispatcherCallback

    35 	*/	

    36 	static CATChld* NewL(CGlobalPhonemanager& aGloblePhone,

    37 			             CCtsyDispatcherCallback& aCtsyDispatcherCallback);

    38 	

    39 	/**

    40 	*  static NewLC

    41 	*

    42 	* @param aGloblePhone

    43 	* @param aCtsyDispatcherCallback

    44 	*/	

    45 	static CATChld* NewLC(CGlobalPhonemanager& aGloblePhone,

    46 			              CCtsyDispatcherCallback& aCtsyDispatcherCallback);

    47 	

    48 	/**

    49 	 * Destructor

    50 	 * 

    51 	 */

    52 	virtual ~CATChld();

    53 	

    54 	/**

    55 	* Virtual function. Inherited from CAtCommandBase

    56 	* 

    57 	* Execute AT Command

    58 	*/

    59 	virtual void ExecuteCommand();

    60 		

    61 	/**

    62 	* Will be called by AT Manager whenever a event was triggered

    63 	* 

    64 	* @param aEventSource

    65 	* @param aStatus

    66 	*/

    67 	virtual void EventSignal(TAtEventSource aEventSource, TInt aStatus);

    68 	

    69 	/**

    70 	* Virtual function. Inherited from CAtCommandBase

    71 	* 

    72 	* @param aResponseBuf Line buf reading from baseband 

    73 	*/

    74 	virtual void ParseResponseL(const TDesC8& aResponseBuf);

    75 	

    76 	/**

    77 	* Start AT request

    78 	* 

    79 	*/

    80 	virtual void StartRequest();	

    81 	

    82 public:

    83 	

    84 	/**

    85 	 * IPC type

    86 	 * 

    87 	 */

    88 	enum TIpcType

    89 		{

    90 		ELtsyReqCallHangup = 0,   //Invoke function HandleHangUpReqL(TInt aCallId, TInt aHangupCause)     

    91 		ELtsyReqCallHold = 1,	  //Invoke function HandleHoldReqL(TInt aCallId)

    92 		ELtsyReqCallResume = 2,	  //Invoke function HandleResumeReqL(TInt aCallId)

    93 		ELtsyReqCallSwap = 3	  //Invoke function HandleSwapReqL(TInt aHeldCallId, TInt aConnectedCallId)

    94 		};

    95 	

    96 	/**

    97 	 * which identify AT type

    98 	 * 

    99 	 */

   100 	enum TChldType

   101 		{

   102 		EReleaseAllHeldCallOrUDUB = 0,

   103 		EReleaseAllActiveCallAndAcceptHeldWaiting = 1,

   104 		EHeldAllActiveCallAndAcceptHeldWaiting = 2,  //For held a call and resume a call

   105 		EAddHeldCallToConversation = 3,

   106 		ECallTranster =  4,

   107 		ERleaseSpecificCall = 5,

   108 		EHeldAllActiveCallExceptCallX = 6

   109 		};

   110 	

   111 	/**

   112 	 *Set IPC type 

   113 	 * 

   114 	 * @param aIpcType

   115 	 */

   116 	void SetIpcType(TIpcType aIpcType);	

   117 	

   118 	/**

   119 	 * Set chld type

   120 	 * 

   121 	 * @param aManageType

   122 	 */

   123 	void SetChldType(TChldType aManageType);

   124 	

   125 	/**

   126 	 * Set call id

   127 	 * 

   128 	 * @param aCallId

   129 	 */

   130 	void SetCallId(TInt aCallId);

   131 	

   132 	/**

   133 	 * Set connected call id

   134 	 * 

   135 	 * @param aConnectedCallId

   136 	 */

   137 	void SetConnectedCallId(TInt aConnectedCallId);

   138 	

   139 	/**

   140 	 * Set hang up case 

   141 	 * 

   142 	 * @param aHangupCase

   143 	 */

   144 	void SetHangupCase(TInt aHangupCase);

   145 	

   146 	/**

   147 	 * Init member

   148 	 * 

   149 	 */

   150 	void InitVariable();

   151 	

   152 	/**

   153 	 * Prevent second holding when the aHoldCallId is holded

   154 	 * 

   155 	 * @param aHoldCallId

   156 	 */

   157 	TBool IsHoldCall(TInt aHoldCallId);

   158 	

   159 	/**

   160 	 * Prevent second resumeing when the aActiveCallId is actived

   161 	 * 

   162 	 * @param aActiveCallId

   163 	 */

   164 	TBool IsActiveCall(TInt aActiveCallId);

   165 	

   166 protected:

   167 	

   168 	/**

   169 	* Constructor

   170 	*

   171 	* @param aGloblePhone

   172 	* @param aCtsyDispatcherCallback

   173 	*/	

   174 	CATChld(CGlobalPhonemanager& aGloblePhone,

   175 			CCtsyDispatcherCallback& aCtsyDispatcherCallback);

   176 	

   177 	/**

   178 	* 2nd Constructor

   179 	*/	

   180 	void ConstructL();

   181 

   182 	/**

   183 	* The last execute end of this command

   184 	* 

   185 	*/	

   186 	virtual void Complete();

   187 	

   188 private:

   189 	

   190 	/**

   191 	 * AT command execute step

   192 	 * 

   193 	 */

   194 	enum TATStep

   195 		{

   196 		EATNotInProgress,

   197 		EATWaitForWriteComplete,

   198 		EATReadComplete

   199 		};

   200 	

   201 private:

   202 	/**

   203 	 * Handle IO errors

   204 	 * 

   205 	 */

   206 	void HandleIOError();

   207 	

   208 	/**

   209 	 * Handle response error

   210 	 * 

   211 	 */

   212 	void HandleResponseError();

   213 	

   214 	/**

   215 	 * Handle response OK

   216 	 * 

   217 	 */

   218 	void HandleCHLDComplete();

   219 	

   220 	/**

   221 	 * Hang up call complete

   222 	 * 

   223 	 */

   224 	void HandleHangupComplete();

   225 	

   226 	/**

   227 	 * Hold call complete

   228 	 * 

   229 	 */

   230 	void HandleHoldComplete();

   231 	

   232 	/**

   233 	 * Resume call complete

   234 	 * 

   235 	 */

   236 	void HandleResumeComplete();

   237 	

   238 	/**

   239 	 * Swap call complete

   240 	 * 

   241 	 */

   242 	void HandleSwapComplete();

   243 	

   244 private:

   245 	

   246 	/**

   247 	 * I/O error when Read or Write

   248 	 * include timeout

   249 	 */

   250 	TInt iIOStatus;

   251 	

   252 	/**

   253 	 * At command return errors

   254 	 * 

   255 	 */

   256 	TInt iATResult;

   257 		

   258 	/**

   259 	 * Identifier step

   260 	 * 

   261 	 */

   262 	TATStep iATStep;

   263 	

   264 	/**

   265 	 * 

   266 	 * 

   267 	 */

   268 	TIpcType iIpcType;

   269 	

   270 	/**

   271 	 * 

   272 	 * 

   273 	 */

   274 	TChldType iChldType;

   275 	

   276 	/**

   277 	 * for hangup/hold/resum/swap

   278 	 * 

   279 	 */

   280 	TInt iCallId;

   281 	

   282 	/**

   283 	 * for swap

   284 	 * 

   285 	 */

   286 	TInt iConnectedCallId;

   287 	

   288 	/**

   289 	 * for hangup

   290 	 * 

   291 	 */

   292 	TInt iHangupCause;

   293 	

   294 	};

   295 

   296 #endif /*ATCHLD_H_*/