1 // Copyright (c) 2008-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 // cltsydispatchcallcontrolhandler.cpp

    15 //

    16 

    17 #include <ctsy/ltsy/cctsydispatchercallback.h>

    18 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    19 

    20 

    21 

    22 #include "cltsycallcontrolhandler.h"

    23 #include "ltsymacros.h"

    24 #include <ctsy/ltsy/ltsylogger.h>

    25 

    26 // Can be removed in real LTSY implementation

    27 #include MTEST_INCLUDE_MOCKLTSYENGINE_HEADER

    28 

    29 CLtsyCallControlHandler::CLtsyCallControlHandler(

    30 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    31 	: iCtsyDispatcherCallback(aCtsyDispatcherCallback)

    32 	{

    33 	}

    34 

    35 

    36 CLtsyCallControlHandler::~CLtsyCallControlHandler()

    37 	{

    38 	}

    39 

    40 

    41 CLtsyCallControlHandler* CLtsyCallControlHandler::NewLC(

    42 	CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    43 	{

    44 	TSYLOGENTRYEXIT;

    45 	CLtsyCallControlHandler* self = new (ELeave) CLtsyCallControlHandler(aCtsyDispatcherCallback);

    46 	CleanupStack::PushL(self);

    47 	self->ConstructL();

    48 	return self;

    49 	}

    50 

    51 

    52 CLtsyCallControlHandler* CLtsyCallControlHandler::NewL(CCtsyDispatcherCallback& aCtsyDispatcherCallback)

    53 	{

    54 	TSYLOGENTRYEXIT;

    55 	CLtsyCallControlHandler* self=

    56 			CLtsyCallControlHandler::NewLC(aCtsyDispatcherCallback);

    57 	CleanupStack::Pop(self);

    58 	return self;

    59 	}

    60 

    61 

    62 void CLtsyCallControlHandler::ConstructL()

    63 /**

    64  * Second phase constructor.

    65  */

    66 	{

    67 	TSYLOGENTRYEXIT;

    68 

    69 

    70 	} // CLtsyCallControlHandler::ConstructL

    71 

    72 TBool CLtsyCallControlHandler::IsInterfaceSupported(TLtsyDispatchInterfaceApiId aDispatchApiId)

    73 /**

    74  * Returns whether a Dispatch Interface API is supported or not.

    75  *

    76  * @param aDispatchApiId Id of Dispatch interface being queried

    77  * @return indication whether interface is supported or not

    78  */

    79 	{

    80 	// REMOVE this line when implementing for real LTSY

    81 	MTEST_QUERY_SUPPORT_MOCKLTSYENGINE(KDispatchCallControlFuncUnitId, aDispatchApiId);

    82 

    83 	/* uncomment when implementing for real LTSY 

    84 	switch(aDispatchApiId)

    85 		{

    86 		// Insert ApiIds when support is provided in LTSY e.g.

    87 		// case MLtsyDispatchPhoneBootNotifySimStatusReady::KLtsyDispatchPhoneBootNotifySimStatusReadyApiId: return ETrue;

    88 

    89 		default:

    90 			return EFalse;

    91 		}

    92 	*/

    93 	}

    94 

    95 void CLtsyCallControlHandler::IsCallbackIndicatorSupported(TLtsyDispatchIndIdGroup aIdGroup, TUint32& aIndIdBitMask)

    96 /**

    97  * Returns the set of callback indicators that are supported.

    98  *

    99  * @param aIdGroup ID of group that is being queried e.g. aIdGroup=EIndIdGroup1

   100  * @param aIndIdBitMask [out] argument that should return a bitmask indicating which indicator callbacks are supported.

   101  */

   102 	{

   103 	// REMOVE this line when implementing for real LTSY

   104 	MTEST_QUERY_IND_SUPPORT_MOCKLTSYENGINE(KDispatchCallControlFuncUnitId, aIdGroup, aIndIdBitMask);

   105 

   106 	//Create bitmask with bitset for each indicator ID that is supported. E.g.

   107 	/*

   108 	if(aIdGroup == EIndIdGroup1)

   109 		aIndIdBitMask = KLtsyDispatchPhoneNotifyNetworkModeChangeIndId |

   110 						KLtsyDispatchPhoneNotifyEgprsInfoChangeIndId |

   111 						KLtsyDispatchPhoneNotifySignalStrengthChangeIndId;

   112 	else

   113 		aIndIdBitMask = 0; //no indicators from other groups supported

   114 	*/

   115 	}

   116 

   117 TInt CLtsyCallControlHandler::HandleAnswerReqL(TInt aCallId, TBool aIsIsvCall)

   118 /**

   119  * This request is completed by invoking

   120  * CCtsyDispatcherCallback::CallbackCallControlAnswerComp()

   121  *

   122  * @param aCallId The Call ID of the call to answer.

   123  *

   124  * @param aIsIsvCall ETrue if the request to answer the call comes from a

   125  * 3rd party application, EFalse otherwise. This parameter exists in case the

   126  * LTSY wishes to perform special handling of ISV calls.

   127  *

   128  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   129  * or another error code to indicate the failure otherwise.

   130  */

   131 	{

   132 	TSYLOGENTRYEXIT;

   133 

   134 	TInt ret = KErrNotSupported;

   135 

   136 	// Add implementation here.......

   137 

   138 	// REMOVE this line when implementing for real LTSY

   139 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   140 		MLtsyDispatchCallControlAnswer::KLtsyDispatchCallControlAnswerApiId, aCallId, aIsIsvCall);

   141 

   142 	return TSYLOGSETEXITERR(ret);

   143 	} // CLtsyCallControlHandler::HandleAnswerReqL

   144 

   145 

   146 TInt CLtsyCallControlHandler::HandleHoldReqL(TInt aCallId)

   147 /**

   148  * This request is completed by invoking

   149  * CCtsyDispatcherCallback::CallbackCallControlHoldComp()

   150  *

   151  * @param aCallId The Call ID of the call to hold.

   152  *

   153  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   154  * or another error code to indicate the failure otherwise.

   155  */

   156 	{

   157 	TSYLOGENTRYEXIT;

   158 

   159 	TInt ret = KErrNotSupported;

   160 

   161 	// Add implementation here.......

   162 

   163 	// REMOVE this line when implementing for real LTSY

   164 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHold::KLtsyDispatchCallControlHoldApiId, aCallId);

   165 

   166 	return TSYLOGSETEXITERR(ret);

   167 	} // CLtsyCallControlHandler::HandleHoldReqL

   168 

   169 

   170 TInt CLtsyCallControlHandler::HandleDialEmergencyReqL(const TDes& aEmergencyNumber)

   171 /**

   172  * This request is completed by invoking

   173  * CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp()

   174  *

   175  * @param aEmergencyNumber The emergency phone number to dial.  The descriptor

   176  * should be of type RMobileENStore::TEmergencyNumber.

   177  *

   178  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   179  * or another error code to indicate the failure otherwise.

   180  */

   181 	{

   182 	TSYLOGENTRYEXIT;

   183 

   184 	TInt ret = KErrNotSupported;

   185 

   186 	// Add implementation here.......

   187 

   188 	// REMOVE this line when implementing for real LTSY

   189 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialEmergency::KLtsyDispatchCallControlDialEmergencyApiId, &aEmergencyNumber);

   190 

   191 	return TSYLOGSETEXITERR(ret);

   192 	} // CLtsyCallControlHandler::HandleDialEmergencyReqL

   193 

   194 

   195 TInt CLtsyCallControlHandler::HandleStopDtmfToneReqL(TInt aCallId)

   196 /**

   197  * This request is completed by invoking

   198  * CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp()

   199  *

   200  * @param aCallId Call ID of the connected call the stop request will be sent

   201  * through.

   202  *

   203  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   204  * or another error code to indicate the failure otherwise.

   205  */

   206 	{

   207 	TSYLOGENTRYEXIT;

   208 

   209 	TInt ret = KErrNotSupported;

   210 

   211 	// Add implementation here.......

   212 

   213 	// REMOVE this line when implementing for real LTSY

   214 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   215 			MLtsyDispatchCallControlStopDtmfTone::KLtsyDispatchCallControlStopDtmfToneApiId,

   216 			aCallId);

   217 

   218 	return TSYLOGSETEXITERR(ret);

   219 	} // CLtsyCallControlHandler::HandleStopDtmfToneReqL

   220 

   221 

   222 TInt CLtsyCallControlHandler::HandleSetActiveAlsLineReqL(RMobilePhone::TMobilePhoneALSLine aAlsLine)

   223 /**

   224  * This request is completed by invoking

   225  * CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp()

   226  *

   227  * @param aAlsLine The new active ALS line.

   228  *

   229  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   230  * or another error code to indicate the failure otherwise.

   231  */

   232 	{

   233 	TSYLOGENTRYEXIT;

   234 

   235 	TInt ret = KErrNotSupported;

   236 

   237 	// Add implementation here.......

   238 

   239 	// REMOVE this line when implementing for real LTSY

   240 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   241 		MLtsyDispatchCallControlSetActiveAlsLine::KLtsyDispatchCallControlSetActiveAlsLineApiId, &aAlsLine);

   242 

   243 	return TSYLOGSETEXITERR(ret);

   244 	} // CLtsyCallControlHandler::HandleSetActiveAlsLineReqL

   245 

   246 

   247 TInt CLtsyCallControlHandler::HandleSendDtmfTonesCancelReqL(TInt aCallId)

   248 /**

   249  * This request is completed by invoking

   250  * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp()

   251  *

   252  * @param aCallId The Call ID through which the cancel request should be sent.

   253  *

   254  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   255  * or another error code to indicate the failure otherwise.

   256  */

   257 	{

   258 	TSYLOGENTRYEXIT;

   259 

   260 	TInt ret = KErrNotSupported;

   261 

   262 	// Add implementation here.......

   263 

   264 	// REMOVE this line when implementing for real LTSY

   265 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTonesCancel::KLtsyDispatchCallControlSendDtmfTonesCancelApiId,

   266 				aCallId);

   267 

   268 	return TSYLOGSETEXITERR(ret);

   269 	} // CLtsyCallControlHandler::HandleSendDtmfTonesCancelReqL

   270 

   271 

   272 TInt CLtsyCallControlHandler::HandleHangUpReqL(TInt aCallId, TInt aHangupCause)

   273 /**

   274  * This request is completed by invoking

   275  * CCtsyDispatcherCallback::CallbackCallControlHangUpComp()

   276  *

   277  * @param aCallId The Call ID of the call to hang up.

   278  *

   279  * @param aHangupCause The reason for the hang up request.

   280  *

   281  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   282  * or another error code to indicate the failure otherwise.

   283  */

   284 	{

   285 	TSYLOGENTRYEXIT;

   286 

   287 	TInt ret = KErrNotSupported;

   288 

   289 	// Add implementation here.......

   290 

   291 	// REMOVE this line when implementing for real LTSY

   292 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlHangUp::KLtsyDispatchCallControlHangUpApiId, aCallId, aHangupCause);

   293 

   294 	return TSYLOGSETEXITERR(ret);

   295 	} // CLtsyCallControlHandler::HandleHangUpReqL

   296 

   297 

   298 TInt CLtsyCallControlHandler::HandleResumeReqL(TInt aCallId)

   299 /**

   300  * This request is completed by invoking

   301  * CCtsyDispatcherCallback::CallbackCallControlResumeComp()

   302  *

   303  * @param aCallId The Call ID of the call to resume.

   304  *

   305  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   306  * or another error code to indicate the failure otherwise.

   307  */

   308 	{

   309 	TSYLOGENTRYEXIT;

   310 

   311 	TInt ret = KErrNotSupported;

   312 

   313 	// Add implementation here.......

   314 

   315 	// REMOVE this line when implementing for real LTSY

   316 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlResume::KLtsyDispatchCallControlResumeApiId, aCallId);

   317 

   318 	return TSYLOGSETEXITERR(ret);

   319 	} // CLtsyCallControlHandler::HandleResumeReqL

   320 

   321 

   322 TInt CLtsyCallControlHandler::HandleSetDynamicHscsdParamsReqL(

   323 	TInt aCallId, const RMobileCall::TMobileHscsdCallParamsV1& aHscsdParams)

   324 /**

   325  * This request is completed by invoking

   326  * CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp()

   327  *

   328  * @param aCallId The call ID of the data call.

   329  *

   330  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   331  * or another error code to indicate the failure otherwise.

   332  */

   333 	{

   334 	TSYLOGENTRYEXIT;

   335 

   336 	TInt ret = KErrNotSupported;

   337 

   338 	// Add implementation here.......

   339 

   340 	// REMOVE this line when implementing for real LTSY

   341 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSetDynamicHscsdParams::KLtsyDispatchCallControlSetDynamicHscsdParamsApiId, aCallId, &aHscsdParams);

   342 

   343 	return TSYLOGSETEXITERR(ret);

   344 	} // CLtsyCallControlHandler::HandleSetDynamicHscsdParamsReqL

   345 

   346 

   347 TInt CLtsyCallControlHandler::HandleDialVoiceReqL(RMobilePhone::TMobilePhoneALSLine aLine,

   348 	const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileCallParamsV1& aCallParamsV1,

   349 	TBool aIsIsvCall, RMobileCall::TCallParamOrigin aCallOrigin, TBool aPerformFdnCheck)

   350 /**

   351  * This request is completed by invoking

   352  * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp()

   353  *

   354  * @param aCallLine The line to use to dial the call.

   355  *

   356  * @param aDialledParty Details about the dialled party including the phone

   357  * number to dial.

   358  *

   359  * @param aCallParamsV1 The call parameters of the call to dial.

   360  *

   361  * @param aIsIsvCall Indicates whether the call originated from a third party

   362  * application.

   363  *

   364  * @param aCallOrigin The origin of the dial request. e.g. Whether the dial

   365  * came from an Etel client or the SIM or another source.

   366  *

   367  * @param aPerformFdnCheck whether or not a Fixed Dialling Number check should be

   368  * performed.

   369  *

   370  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   371  * or another error code to indicate the failure otherwise.

   372  */

   373 	{

   374 	TSYLOGENTRYEXIT;

   375 

   376 	TInt ret = KErrNotSupported;

   377 

   378 	// Add implementation here.......

   379 

   380 	// REMOVE this line when implementing for real LTSY

   381 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialVoice::KLtsyDispatchCallControlDialVoiceApiId,

   382 			&aLine, &aDialledParty, &aCallParamsV1, aIsIsvCall, &aCallOrigin, aPerformFdnCheck);

   383 

   384 	return TSYLOGSETEXITERR(ret);

   385 	} // CLtsyCallControlHandler::HandleDialReqL

   386 

   387 

   388 TInt CLtsyCallControlHandler::HandleTransferReqL(TInt aHeldCallId, TInt aSecondCallId)

   389 /**

   390  * This request is completed by invoking

   391  * CCtsyDispatcherCallback::CallbackCallControlTransferComp()

   392  *

   393  * @param aHeldCallId Call ID of the held call to transfer.

   394  *

   395  * @param aSecondCallId Call ID of the other to transfer the held call to.

   396  *

   397  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   398  * or another error code to indicate the failure otherwise.

   399  */

   400 	{

   401 	TSYLOGENTRYEXIT;

   402 

   403 	TInt ret = KErrNotSupported;

   404 

   405 	// Add implementation here.......

   406 

   407 	// REMOVE this line when implementing for real LTSY

   408 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlTransfer::KLtsyDispatchCallControlTransferApiId,

   409 			aHeldCallId, aSecondCallId);

   410 

   411 	return TSYLOGSETEXITERR(ret);

   412 	} // CLtsyCallControlHandler::HandleTransferReqL

   413 

   414 

   415 TInt CLtsyCallControlHandler::HandleSendDtmfTonesReqL(TInt aCallId, const TDesC &aTones)

   416 /**

   417  * This request is completed by invoking

   418  * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp()

   419  *

   420  * @param aCallId The Call ID of the call through which the DTMF string will be

   421  * sent.

   422  *

   423  * @param aTones Tones to send through the active call.

   424  *

   425  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   426  * or another error code to indicate the failure otherwise.

   427  */

   428 	{

   429 	TSYLOGENTRYEXIT;

   430 

   431 	TInt ret = KErrNotSupported;

   432 

   433 	// Add implementation here.......

   434 

   435 	// REMOVE this line when implementing for real LTSY

   436 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret,

   437 			KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSendDtmfTones::KLtsyDispatchCallControlSendDtmfTonesApiId,

   438 			aCallId, &aTones);

   439 

   440 	return TSYLOGSETEXITERR(ret);

   441 	} // CLtsyCallControlHandler::HandleSendDtmfTonesReqL

   442 

   443 

   444 TInt CLtsyCallControlHandler::HandleGetIdentityServiceStatusReqL(RMobilePhone::TMobilePhoneIdService aService)

   445 /**

   446  * This request is completed by invoking

   447  * CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp()

   448  *

   449  * @param aService The service whose status needs to be retrieved.

   450  *

   451  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   452  * or another error code to indicate the failure otherwise.

   453  */

   454 	{

   455 	TSYLOGENTRYEXIT;

   456 

   457 	TInt ret = KErrNotSupported;

   458 

   459 	// Add implementation here.......

   460 

   461 	// REMOVE this line when implementing for real LTSY

   462 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   463 			MLtsyDispatchCallControlGetIdentityServiceStatus::KLtsyDispatchCallControlGetIdentityServiceStatusApiId,

   464 			&aService);

   465 

   466 	return TSYLOGSETEXITERR(ret);

   467 	} // CLtsyCallControlHandler::HandleGetIdentityServiceStatusReqL

   468 

   469 

   470 TInt CLtsyCallControlHandler::HandleSwapReqL(TInt aHeldCallId, TInt aConnectedCallId)

   471 /**

   472  * This request is completed by invoking

   473  * CCtsyDispatcherCallback::CallbackCallControlSwapComp()

   474  *

   475  * @param aHeldCallId The Call ID of the held call to swap.

   476  *

   477  * @param aConnectedCallId The Call ID of the connected call to swap.

   478  *

   479  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   480  * or another error code to indicate the failure otherwise.

   481  */

   482 	{

   483 	TSYLOGENTRYEXIT;

   484 

   485 	TInt ret = KErrNotSupported;

   486 

   487 	// Add implementation here.......

   488 

   489 	// REMOVE this line when implementing for real LTSY

   490 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlSwap::KLtsyDispatchCallControlSwapApiId,

   491 			aHeldCallId, aConnectedCallId);

   492 

   493 	return TSYLOGSETEXITERR(ret);

   494 	} // CLtsyCallControlHandler::HandleSwapReqL

   495 

   496 

   497 TInt CLtsyCallControlHandler::HandleLoanDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort)

   498 /**

   499  * This request is part of

   500  * MLtsyDispatchCallControlLoanDataPort::HandleLoanDataPortSyncL()

   501  *

   502  * @param aCallId Call ID of the data call requiring the data port.

   503  *

   504  * @param aCommPort Output parameter. The communications port information

   505  * retrieved by a client using the RCall::LoanDataPort() API.

   506  *

   507  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   508  * or another error code to indicate the failure otherwise.

   509  */

   510 	{

   511 	TSYLOGENTRYEXIT;

   512 

   513 	TInt ret = KErrNotSupported;

   514 

   515 	// Add implementation here.......

   516 

   517 	// REMOVE this line when implementing for real LTSY

   518 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlLoanDataPort::KLtsyDispatchCallControlLoanDataPortApiId,

   519 		aCallId, &aCommPort);

   520 

   521 	return TSYLOGSETEXITERR(ret);

   522 	} // CLtsyCallControlHandler::HandleLoanDataPortSyncL

   523 

   524 

   525 TInt CLtsyCallControlHandler::HandleRecoverDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort)

   526 /**

   527  * This request is part of

   528  * MLtsyDispatchCallControlRecoverDataPort::HandleRecoverDataPortSyncL()

   529  *

   530  * @param aCallId Call ID of the data call requiring the data port.

   531  *

   532  * @param aCommPort The data port to recover.  This contains the details previously

   533  * returned by a call to RCall::LoanDataPort()

   534  *

   535  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   536  * or another error code to indicate the failure otherwise.

   537  */

   538 	{

   539 	TSYLOGENTRYEXIT;

   540 

   541 	TInt ret = KErrNotSupported;

   542 

   543 	// Add implementation here.......

   544 

   545 	// REMOVE this line when implementing for real LTSY

   546 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   547 			MLtsyDispatchCallControlRecoverDataPort::KLtsyDispatchCallControlRecoverDataPortApiId,

   548 			aCallId, &aCommPort);

   549 

   550 	return TSYLOGSETEXITERR(ret);

   551 	} // CLtsyCallControlHandler::HandleRecoverDataPortSyncL

   552 

   553 

   554 TInt CLtsyCallControlHandler::HandleStartDtmfToneReqL(TInt aCallId, const TChar& aTone)

   555 /**

   556  * This request is completed by invoking

   557  * CCtsyDispatcherCallback::CallbackCallControlStartDtmfTone()

   558  *

   559  * @param aCallId Call ID of the connected call through which the DTMF tone

   560  * will be sent.

   561  *

   562  * @param aTone The tone character to send through the call.

   563  *

   564  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   565  * or another error code to indicate the failure otherwise.

   566  */

   567 	{

   568 	TSYLOGENTRYEXIT;

   569 

   570 	TInt ret = KErrNotSupported;

   571 

   572 	// Add implementation here.......

   573 

   574 	// REMOVE this line when implementing for real LTSY

   575 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   576 		MLtsyDispatchCallControlStartDtmfTone::KLtsyDispatchCallControlStartDtmfToneApiId,

   577 		aCallId, &aTone);

   578 

   579 	return TSYLOGSETEXITERR(ret);

   580 	} // CLtsyCallControlHandler::HandleStartDtmfToneSyncL

   581 

   582 

   583 TInt CLtsyCallControlHandler::HandleGetActiveAlsLineReqL()

   584 /**

   585  * This request is completed by invoking

   586  * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()

   587  *

   588  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   589  * or another error code to indicate the failure otherwise.

   590  */

   591 	{

   592 	TSYLOGENTRYEXIT;

   593 

   594 	TInt ret = KErrNotSupported;

   595 

   596 	// Add implementation here.......

   597 

   598 	// REMOVE this line when implementing for real LTSY

   599 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId, KLtsyDispatchCallControlGetActiveAlsLineApiId);

   600 

   601 	return TSYLOGSETEXITERR(ret);

   602 	} // CLtsyCallControlHandler::HandleGetActiveAlsLineReqL

   603 

   604 TInt CLtsyCallControlHandler::HandleDialDataReqL(const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileDataCallParamsV1& aCallParamsV1, TBool aPerformFdnCheck)

   605 /**

   606  * This request is completed by invoking

   607  * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()

   608  *

   609  * @param aLine The line to use to dial the call.

   610  *

   611  * @param aDialledParty Details about the dialled party including the phone

   612  * number to dial.

   613  *

   614  * @param aCallParamsV1 The call parameters of the call to dial.

   615  * 

   616  * @param aPerformFdnCheck whether or not a Fixed Dialling Number check should be

   617  * performed.

   618  *

   619  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   620  * or another error code to indicate the failure otherwise.

   621  */

   622 	{

   623 	TSYLOGENTRYEXIT;

   624 

   625 	TInt ret = KErrNotSupported;

   626 

   627 	// Add implementation here.......

   628 

   629 	// REMOVE this line when implementing for real LTSY

   630 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlDialData::KLtsyDispatchCallControlDialDataApiId,

   631 			&aDialledParty, &aCallParamsV1, aPerformFdnCheck);

   632 

   633 	return TSYLOGSETEXITERR(ret);

   634 	} // CLtsyCallControlHandler::HandleDialDataReqL

   635 

   636 TInt CLtsyCallControlHandler::HandleQueryIsEmergencyNumberSyncL(const TDesC& aNumber, TBool& aIsEmergencyNumber)

   637 /**

   638  * This request is part of

   639  * MLtsyDispatchCallControlQueryIsEmergencyNumber::HandleQueryIsEmergencyNumberSyncL()

   640  *

   641  * @param aNumber Input parameter. The phone number being queried to see

   642  * if it is an emergency number or not.

   643  *

   644  * @param aIsEmergencyNumber Output parameter used to indicate whether the

   645  * aNumber parameter is an emergency number. ETrue if it is, EFalse otherwise.

   646  *

   647  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   648  * or another error code to indicate the failure otherwise.

   649  */

   650 	{

   651 	TSYLOGENTRYEXIT;

   652 

   653 	TInt ret = KErrNotSupported;

   654 

   655 	// Add implementation here.......

   656 

   657 	// REMOVE this line when implementing for real LTSY

   658 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlQueryIsEmergencyNumber::KLtsyDispatchCallControlQueryIsEmergencyNumberApiId,

   659 			&aNumber, &aIsEmergencyNumber);

   660 

   661 	return TSYLOGSETEXITERR(ret);

   662 	} // CLtsyCallControlHandler::HandleQueryIsEmergencyNumberSyncL

   663 

   664 

   665 TInt CLtsyCallControlHandler::HandleGetAlsPpSupportL()

   666 /**

   667  * This request is completed by invoking

   668  * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp()

   669  *

   670  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   671  * or another error code to indicate the failure otherwise.

   672  */

   673 	{

   674 	TSYLOGENTRYEXIT;

   675 

   676 	TInt ret = KErrNotSupported;

   677 

   678 	// Add implementation here.......

   679 

   680 	// REMOVE this line when implementing for real LTSY

   681 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId,

   682 			MLtsyDispatchCallControlGetAlsPpSupport::KLtsyDispatchCallControlGetAlsPpSupportApiId);

   683 

   684 	return TSYLOGSETEXITERR(ret);

   685 	} // CLtsyCallControlHandler::HandleGetAlsPp

   686 

   687 TInt CLtsyCallControlHandler::HandleGetAlsBlockedStatusL()

   688 /**

   689  * This request is completed by invoking

   690  * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp()

   691  *

   692  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   693  * or another error code to indicate the failure otherwise.

   694  */

   695 	{

   696 	TSYLOGENTRYEXIT;

   697 

   698 	TInt ret = KErrNotSupported;

   699 

   700 	// Add implementation here.......

   701 

   702 	// REMOVE this line when implementing for real LTSY

   703 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId,

   704 			MLtsyDispatchCallControlGetAlsBlockedStatus::KLtsyDispatchCallControlGetAlsBlockedStatusApiId);

   705 

   706 	return TSYLOGSETEXITERR(ret);

   707 	} // CLtsyCallControlHandler::HandleGetAlsBlockedStatus

   708 

   709 TInt CLtsyCallControlHandler::HandleSetAlsBlockedL(RMmCustomAPI::TSetAlsBlock aBlocked)

   710 /**

   711  * This request is completed by invoking

   712  * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp()

   713  *

   714  *

   715  * @param aBlocked RMmCustomAPI::EDeactivateBlock when the ALS blocked needs to be deactivate,

   716  *                 RMmCustomAPI::EActivateBlock when the  ALS blocked needs to be activate.

   717  *

   718  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   719  * or another error code to indicate the failure otherwise.

   720  */

   721 	{

   722 	TSYLOGENTRYEXIT;

   723 

   724 	TInt ret = KErrNotSupported;

   725 

   726 	// Add implementation here.......

   727 

   728 	// REMOVE this line when implementing for real LTSY

   729 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   730                                    MLtsyDispatchCallControlSetAlsBlocked::KLtsyDispatchCallControlSetAlsBlockedApiId, aBlocked);

   731 

   732 	return TSYLOGSETEXITERR(ret);

   733 	} // CLtsyCallControlHandler::HandleSetAlsBlockedL

   734 

   735 TInt CLtsyCallControlHandler::HandleGetLifeTimeL()

   736 /**

   737  * This request is completed by invoking

   738  * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp()

   739  *

   740  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   741  * or another error code to indicate the failure otherwise.

   742  */

   743 	{

   744 	TSYLOGENTRYEXIT;

   745 

   746 	TInt ret = KErrNotSupported;

   747 

   748 	// Add implementation here.......

   749 

   750 	// REMOVE this line when implementing for real LTSY

   751 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId,

   752 			MLtsyDispatchCallControlGetLifeTime::KLtsyDispatchCallControlGetLifeTimeApiId);

   753 

   754 	return TSYLOGSETEXITERR(ret);

   755 	} // CLtsyCallControlHandler::HandleGetLifeTime

   756 

   757 TInt CLtsyCallControlHandler::HandleTerminateErrorCallL(TInt aCallId)

   758 /**

   759  * This request is completed by invoking

   760  * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp()

   761  *

   762  *

   763  * @param aCallId The Call ID of the call to terminate.

   764  *

   765  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   766  * or another error code to indicate the failure otherwise.

   767  */

   768 	{

   769 	TSYLOGENTRYEXIT;

   770 

   771 	TInt ret = KErrNotSupported;

   772 

   773 	// Add implementation here.......

   774 

   775 	// REMOVE this line when implementing for real LTSY

   776 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId,

   777                                    MLtsyDispatchCallControlTerminateErrorCall::KLtsyDispatchCallControlTerminateErrorCallApiId, aCallId);

   778 

   779 	return TSYLOGSETEXITERR(ret);

   780 	} // CLtsyCallControlHandler::HandleTerminateErrorCallL

   781 

   782 TInt CLtsyCallControlHandler::HandleTerminateAllCallsL()

   783 /**

   784  * This request is completed by invoking

   785  * CCtsyDispatcherCallback::::CallbackCallControlTerminateAllCallsComp()

   786  *

   787  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   788  * or another error code to indicate the failure otherwise.

   789  */

   790 	{

   791 	TSYLOGENTRYEXIT;

   792 

   793 	TInt ret = KErrNotSupported;

   794 

   795 	// Add implementation here.......

   796 

   797 	// REMOVE this line when implementing for real LTSY

   798 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId,

   799                                    MLtsyDispatchCallControlTerminateAllCalls::KLtsyDispatchCallControlTerminateAllCallsApiId);

   800 

   801 	return TSYLOGSETEXITERR(ret);

   802 	} // CLtsyCallControlHandler::HandleTerminateAllCallsL

   803 

   804 TInt CLtsyCallControlHandler::HandleGetCallForwardingIndicatorL()

   805 /**

   806  * This request is completed by invoking

   807  * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp()

   808  *

   809  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   810  * or another error code to indicate the failure otherwise.

   811  */

   812 	{

   813 	TSYLOGENTRYEXIT;

   814 

   815 	TInt ret = KErrNotSupported;

   816 

   817 	// Add implementation here.......

   818 

   819 	// REMOVE this line when implementing for real LTSY

   820 	MTEST_ISSUE_MOCKLTSYENGINE_REQ3(ret, KDispatchCallControlFuncUnitId,

   821 			MLtsyDispatchCallControlGetCallForwardingIndicator::KLtsyDispatchCallControlGetCallForwardingIndicatorApiId);

   822 

   823 	return TSYLOGSETEXITERR(ret);

   824 	} // CLtsyCallControlHandler::HandleGetCallForwardingIndicator

   825 

   826 TInt CLtsyCallControlHandler::HandleUpdateLifeTimerReqL(TUint32 aDuration)

   827 /**

   828  * This request is completed by invoking

   829  *  CCtsyDispatcherCallback::CallbackCallControlUpdateLifeTimerComp

   830  *

   831  * @param aDuration Time spent on call since the last invocation of this method.

   832  *

   833  * @return KErrNone on success, KErrNotSupported if this request is not supported,

   834  * or another error code to indicate the failure otherwise.

   835  */

   836 	{

   837 	TSYLOGENTRYEXIT;

   838 

   839 	TInt ret = KErrNotSupported;

   840 

   841 	// Add implementation here.......

   842 

   843 	// REMOVE this line when implementing for real LTSY

   844 	MTEST_ISSUE_MOCKLTSYENGINE_REQ(ret, KDispatchCallControlFuncUnitId, MLtsyDispatchCallControlUpdateLifeTimer::KLtsyDispatchCallControlUpdateLifeTimerApiId,

   845 			aDuration);

   846 

   847 	return TSYLOGSETEXITERR(ret);

   848 	} // CLtsyCallControlHandler:::HandleUpdateLifeTimerReqL

   849