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 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to CallControl related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHCALLCONTROLINTERFACE_H_

    28 #define MLTSYDISPATCHCALLCONTROLINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 #include <etelmm.h>

    32 #include <ctsy/rmmcustomapi.h>

    33 

    34 class MLtsyDispatchCallControlAnswer : public MLtsyDispatchInterface

    35 	{

    36 public:

    37 

    38 	static const TInt KLtsyDispatchCallControlAnswerApiId = KDispatchCallControlFuncUnitId + 1;

    39 

    40 	/**

    41 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallAnswer

    42 	 * request from the CTSY.

    43 	 *

    44 	 * It is a request call that is completed by invoking

    45 	 * CCtsyDispatcherCallback::CallbackCallControlAnswerComp()

    46 	 *

    47 	 * Implementation of this interface should answer the specified incoming call.

    48 	 *

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

    50 	 *

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

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

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

    54 	 *

    55 	 * @return KErrNone on success, otherwise another error code indicating the

    56 	 * failure.

    57 	 *

    58 	 * @see RCall::AnswerIncomingCall()

    59 	 * @see RCall::AnswerIncomingCallISV()

    60 	 * @see CTelephony::AnswerIncomingCall()

    61 	 */

    62 	virtual TInt HandleAnswerReqL(TInt aCallId, TBool aIsIsvCall) = 0;

    63 

    64 	}; // class MLtsyDispatchCallControlAnswer

    65 

    66 

    67 

    68 class MLtsyDispatchCallControlHold : public MLtsyDispatchInterface

    69 	{

    70 public:

    71 

    72 	static const TInt KLtsyDispatchCallControlHoldApiId = KDispatchCallControlFuncUnitId + 2;

    73 

    74 	/**

    75 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallHold

    76 	 * request from the CTSY.

    77 	 *

    78 	 * It is a request call that is completed by invoking

    79 	 * CCtsyDispatcherCallback::CallbackCallControlHoldComp()

    80 	 *

    81 	 * Implementation of this interface should hold the specified call.

    82 	 *

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

    84 	 *

    85 	 * @return KErrNone on success, otherwise another error code indicating the

    86 	 * failure.

    87 	 *

    88 	 * @see RMobileCall::Hold()

    89 	 */

    90 	virtual TInt HandleHoldReqL(TInt aCallId) = 0;

    91 

    92 	}; // class MLtsyDispatchCallControlHold

    93 

    94 

    95 

    96 class MLtsyDispatchCallControlDialEmergency : public MLtsyDispatchInterface

    97 	{

    98 public:

    99 

   100 	static const TInt KLtsyDispatchCallControlDialEmergencyApiId = KDispatchCallControlFuncUnitId + 3;

   101 

   102 	/**

   103 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallDialEmergencyCall

   104 	 * request from the CTSY.

   105 	 *

   106 	 * It is a request call that is completed by invoking

   107 	 * CCtsyDispatcherCallback::CallbackCallControlDialEmergencyComp()

   108 	 *

   109 	 * Implementation of this interface should dial an emergency call to the specified

   110 	 * number.

   111 	 *

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

   113 	 * should be of type RMobileENStore::TEmergencyNumber.

   114 	 *

   115 	 * @return KErrNone on success, otherwise another error code indicating the

   116 	 * failure.

   117 	 *

   118 	 * @see RMobileCall::DialEmergencyCall()

   119 	 */

   120 	virtual TInt HandleDialEmergencyReqL(const TDes& aEmergencyNumber) = 0;

   121 

   122 	}; // class MLtsyDispatchCallControlDialEmergency

   123 

   124 

   125 class MLtsyDispatchCallControlStopDtmfTone : public MLtsyDispatchInterface

   126 	{

   127 public:

   128 

   129 	static const TInt KLtsyDispatchCallControlStopDtmfToneApiId = KDispatchCallControlFuncUnitId + 4;

   130 

   131 	/**

   132 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStopDTMFTone

   133 	 * request from the CTSY.

   134 	 *

   135 	 * It is a request call that is completed by invoking

   136 	 * CCtsyDispatcherCallback::CallbackCallControlStopDtmfToneComp()

   137 	 *

   138 	 * Implementation of this interface should stop sending the DTMF tone previously

   139 	 * started by MLtsyDispatchCallControlStartDtmfTone::HandleStartDtmfToneReqL().

   140 	 *

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

   142 	 * through.

   143 	 *

   144 	 * @return KErrNone on success, otherwise another error code indicating the

   145 	 * failure.

   146 	 *

   147 	 * @see RMobileCall::StopDTMFTone()

   148 	 */

   149 	virtual TInt HandleStopDtmfToneReqL(TInt aCallId) = 0;

   150 

   151 	}; // class MLtsyDispatchCallControlStopDtmfTone

   152 

   153 

   154 

   155 class MLtsyDispatchCallControlSetActiveAlsLine : public MLtsyDispatchInterface

   156 	{

   157 public:

   158 

   159 	static const TInt KLtsyDispatchCallControlSetActiveAlsLineApiId = KDispatchCallControlFuncUnitId + 5;

   160 

   161 	/**

   162 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetALSLine

   163 	 * request from the CTSY.

   164 	 *

   165 	 * It is a request call that is completed by invoking

   166 	 * CCtsyDispatcherCallback::CallbackCallControlSetActiveAlsLineComp()

   167 	 *

   168 	 * Implementation of this interface should set the active ALS line to that

   169 	 * specified.

   170 	 *

   171 	 * @param aAlsLine The new active ALS line.

   172 	 *

   173 	 * @return KErrNone on success, otherwise another error code indicating the

   174 	 * failure.

   175 	 *

   176 	 * @see RMobilePhone::SetALSLine()

   177 	 */

   178 	virtual TInt HandleSetActiveAlsLineReqL(RMobilePhone::TMobilePhoneALSLine aAlsLine) = 0;

   179 

   180 	}; // class MLtsyDispatchCallControlSetActiveAlsLine

   181 

   182 

   183 

   184 class MLtsyDispatchCallControlSendDtmfTonesCancel : public MLtsyDispatchInterface

   185 	{

   186 public:

   187 

   188 	static const TInt KLtsyDispatchCallControlSendDtmfTonesCancelApiId = KDispatchCallControlFuncUnitId + 6;

   189 

   190 	/**

   191 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendDTMFTonesCancel

   192 	 * request from the CTSY.

   193 	 *

   194 	 * It is a request call that is completed by invoking

   195 	 * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesCancelComp()

   196 	 *

   197 	 * Implementation of this interface should attempt to cancel the sending of

   198 	 * a string of DTMF tones which were previously sent by

   199 	 * MLtsyDispatchCallControlSendDtmfTones::HandleSendDtmfTonesReqL()

   200 	 *

   201 	 * @param aCallId The Call ID of the active call that the cancel request relates

   202 	 * to.

   203 	 *

   204 	 * @return KErrNone on success, otherwise another error code indicating the

   205 	 * failure.

   206 	 *

   207 	 * @see RMobilePhone::SendDTMFTones()

   208 	 */

   209 	virtual TInt HandleSendDtmfTonesCancelReqL(TInt aCallId) = 0;

   210 

   211 	}; // class MLtsyDispatchCallControlSendDtmfTonesCancel

   212 

   213 

   214 

   215 class MLtsyDispatchCallControlHangUp : public MLtsyDispatchInterface

   216 	{

   217 public:

   218 

   219 	static const TInt KLtsyDispatchCallControlHangUpApiId = KDispatchCallControlFuncUnitId + 7;

   220 

   221 	/**

   222 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallHangUp

   223 	 * request from the CTSY.

   224 	 *

   225 	 * It is a request call that is completed by invoking

   226 	 * CCtsyDispatcherCallback::CallbackCallControlHangUpComp()

   227 	 *

   228 	 * Implementation of this interface should

   229 	 * make a request to the modem to hang up the call specified

   230 	 * in aCallId.  The completion should be called to indicate the result of

   231 	 * placing the hang up request with the baseband.

   232 	 *

   233 	 *  - If aCallId refers to a connected call, the Common TSY will pass

   234 	 * a hang up cause of KErrGsmReleaseByUser to indicate that the call is

   235 	 * being released by the user.

   236 	 *

   237 	 *  - If aCallId refers to a mobile terminated call which is ringing,

   238 	 * the Common TSY will pass a hang up cause of KErrGsmBusyUserRequest to

   239 	 * indicate that the user is rejecting the incoming call.

   240 	 *

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

   242 	 *

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

   244 	 *

   245 	 * @return KErrNone on success, otherwise another error code indicating the

   246 	 * failure.

   247 	 *

   248 	 * @see RCall::HangUp()

   249 	 */

   250 	virtual TInt HandleHangUpReqL(TInt aCallId, TInt aHangupCause) = 0;

   251 

   252 	}; // class MLtsyDispatchCallControlHangUp

   253 

   254 

   255 

   256 class MLtsyDispatchCallControlResume : public MLtsyDispatchInterface

   257 	{

   258 public:

   259 

   260 	static const TInt KLtsyDispatchCallControlResumeApiId = KDispatchCallControlFuncUnitId + 8;

   261 

   262 	/**

   263 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallResume

   264 	 * request from the CTSY.

   265 	 *

   266 	 * It is a request call that is completed by invoking

   267 	 * CCtsyDispatcherCallback::CallbackCallControlResumeComp()

   268 	 *

   269 	 * Implementation of this interface should resume the specified call.

   270 	 * See 3GPP 24.083

   271 	 *

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

   273 	 *

   274 	 * @return KErrNone on success, otherwise another error code indicating the

   275 	 * failure.

   276 	 *

   277 	 * @see RMobileCall::Resume()

   278 	 */

   279 	virtual TInt HandleResumeReqL(TInt aCallId) = 0;

   280 

   281 	}; // class MLtsyDispatchCallControlResume

   282 

   283 

   284 

   285 class MLtsyDispatchCallControlSetDynamicHscsdParams : public MLtsyDispatchInterface

   286 	{

   287 public:

   288 

   289 	static const TInt KLtsyDispatchCallControlSetDynamicHscsdParamsApiId = KDispatchCallControlFuncUnitId + 9;

   290 

   291 	/**

   292 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallSetDynamicHscsdParams

   293 	 * request from the CTSY.

   294 	 *

   295 	 * It is a request call that is completed by invoking

   296 	 * CCtsyDispatcherCallback::CallbackCallControlSetDynamicHscsdParamsComp()

   297 	 *

   298 	 * Implementation of this interface should set the dynamic HSCSD parameters

   299 	 * of the specified data call.

   300 	 *

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

   302 	 *

   303 	 * @param aHscsdParams The requested dynamic HSCSD parameters.

   304 	 *

   305 	 * @return KErrNone on success, otherwise another error code indicating the

   306 	 * failure.

   307 	 *

   308 	 * @see RMobileCall::SetDynamicHscsdParams()

   309 	 */

   310 	virtual TInt HandleSetDynamicHscsdParamsReqL(TInt aCallId, const RMobileCall::TMobileHscsdCallParamsV1& aHscsdParams) = 0;

   311 

   312 	}; // class MLtsyDispatchCallControlSetDynamicHscsdParams

   313 

   314 

   315 

   316 class MLtsyDispatchCallControlDialVoice : public MLtsyDispatchInterface

   317 	{

   318 public:

   319 

   320 	static const TInt KLtsyDispatchCallControlDialVoiceApiId = KDispatchCallControlFuncUnitId + 10;

   321 

   322 	/**

   323 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallDial

   324 	 * request from the CTSY for dialling a voice call.

   325 	 *

   326 	 * It is a request call that is completed by invoking

   327 	 * CCtsyDispatcherCallback::CallbackCallControlDialVoiceComp()

   328 	 *

   329 	 * Implementation of this interface should

   330 	 * dial the requested voice call and complete the callback to indicate

   331 	 * that an attempt to dial the call has been made.  The callback function is used

   332 	 * to indicate the outcome of this attempt to initiate the dialling process.

   333 	 *

   334 	 * @param aCallLine The line to use to dial the call. This parameter can have

   335 	 * one of two possible values RMobilePhone::EAlternateLinePrimary to use the

   336 	 * primary voice line or RMobilePhone::EAlternateLineAuxiliary to use the

   337 	 * auxiliary voice line.

   338 	 *

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

   340 	 * number to dial.

   341 	 *

   342 	 * @param aCallParamsV1 The call parameters of the call to dial. If aIsIsvCall

   343 	 * is set to ETrue, only the RMobileCall::TMobileCallParamsV1::iIdRestrict

   344 	 * and RMobileCall::TMobileCallParamsV1::iAutoRedial fields are valid.

   345 	 *

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

   347 	 * application which would have used the CTelephony class to dial the call.

   348 	 * This information is provided in case the LTSY wishes to do special handling

   349 	 * for third party calls, for example, not allow third party applications to

   350 	 * place emergency calls. See also

   351 	 * MLtsyDispatchCallControlQueryIsEmergencyNumber::HandleQueryIsEmergencyNumberSyncL()

   352 	 * See also: CTelephony::DialNewCall() and RMobileCall::DialISV()

   353 	 *

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

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

   356 	 * 

   357 	 * @param aPerformFdnCheck whether or not an FDN (Fixed Dialling Number) check should be performed.

   358 	 *

   359 	 * @return KErrNone on success; KErrNotSupported if the LTSY does not

   360 	 * support handling of this request or another error code indicating the

   361 	 * failure otherwise.

   362 	 *

   363 	 * @see RCall::Dial()

   364 	 * @see RMobileCall::DialISV()

   365 	 * @see RMobileCall::DialNoFdnCheck()

   366 	 */

   367 	virtual TInt HandleDialVoiceReqL(RMobilePhone::TMobilePhoneALSLine aCallLine, const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileCallParamsV1& aCallParamsV1, TBool aIsIsvCall, RMobileCall::TCallParamOrigin aCallOrigin,

   368 			TBool aPerformFdnCheck) = 0;

   369 

   370 	}; // class MLtsyDispatchCallControlDialVoice

   371 

   372 

   373 

   374 class MLtsyDispatchCallControlTransfer : public MLtsyDispatchInterface

   375 	{

   376 public:

   377 

   378 	static const TInt KLtsyDispatchCallControlTransferApiId = KDispatchCallControlFuncUnitId + 11;

   379 

   380 	/**

   381 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallTransfer

   382 	 * request from the CTSY.

   383 	 *

   384 	 * It is a request call that is completed by invoking

   385 	 * CCtsyDispatcherCallback::CallbackCallControlTransferComp()

   386 	 *

   387 	 * This request should be completed when the request to transfer the call has

   388 	 * been placed.

   389 	 *

   390 	 * Implementation of this interface should transfer the specified held call.

   391 	 * Transferring a call can be requested when there is one held call and another

   392 	 * call either connected or in the ringing state. When the two remote parties

   393 	 * are transferred to each other, the party requesting this operation (us)

   394 	 * drops out of the call.

   395 	 *

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

   397 	 *

   398 	 * @param aOtherCallId Call ID of the other call to transfer the held call to.

   399 	 * This call is either an incoming call in the ringing state or a connected call.

   400 	 *

   401 	 * @return KErrNone on success, otherwise another error code indicating the

   402 	 * failure.

   403 	 *

   404 	 * @see RMobileCall::Transfer()

   405 	 */

   406 	virtual TInt HandleTransferReqL(TInt aHeldCallId, TInt aOtherCallId) = 0;

   407 

   408 	}; // class MLtsyDispatchCallControlTransfer

   409 

   410 

   411 

   412 class MLtsyDispatchCallControlSendDtmfTones : public MLtsyDispatchInterface

   413 	{

   414 public:

   415 

   416 	static const TInt KLtsyDispatchCallControlSendDtmfTonesApiId = KDispatchCallControlFuncUnitId + 12;

   417 

   418 	/**

   419 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSendDTMFTones

   420 	 * request from the CTSY.

   421 	 *

   422 	 * It is a request call that is completed by invoking

   423 	 * CCtsyDispatcherCallback::CallbackCallControlSendDtmfTonesComp()

   424 	 *

   425 	 * Implementation of this interface should send the specified DTMF string through

   426 	 * the currently active call.

   427 	 *

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

   429 	 * sent.

   430 	 *

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

   432 	 *

   433 	 * @return KErrNone on success, otherwise another error code indicating the

   434 	 * failure.

   435 	 *

   436 	 * @see RMobilePhone::SendDTMFTones()

   437 	 */

   438 	virtual TInt HandleSendDtmfTonesReqL(TInt aCallId, const TDesC& aTones) = 0;

   439 

   440 	}; // class MLtsyDispatchCallControlSendDtmfTones

   441 

   442 

   443 

   444 class MLtsyDispatchCallControlGetIdentityServiceStatus : public MLtsyDispatchInterface

   445 	{

   446 public:

   447 

   448 	static const TInt KLtsyDispatchCallControlGetIdentityServiceStatusApiId = KDispatchCallControlFuncUnitId + 13;

   449 

   450 	/**

   451 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetIdentityServiceStatus

   452 	 * request from the CTSY.

   453 	 *

   454 	 * It is a request call that is completed by invoking

   455 	 * CCtsyDispatcherCallback::CallbackCallControlGetIdentityServiceStatusComp()

   456 	 *

   457 	 * Implementation of this interface should request for the status of the

   458 	 * specified identity service such as the Caller ID Presentation Service.

   459 	 *

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

   461 	 *

   462 	 * @return KErrNone on success, otherwise another error code indicating the

   463 	 * failure.

   464 	 *

   465 	 * @see RMobilePhone::GetIdentityServiceStatus()

   466 	 */

   467 	virtual TInt HandleGetIdentityServiceStatusReqL(RMobilePhone::TMobilePhoneIdService aService) = 0;

   468 

   469 	}; // class MLtsyDispatchCallControlGetIdentityServiceStatus

   470 

   471 

   472 

   473 class MLtsyDispatchCallControlSwap : public MLtsyDispatchInterface

   474 	{

   475 public:

   476 

   477 	static const TInt KLtsyDispatchCallControlSwapApiId = KDispatchCallControlFuncUnitId + 14;

   478 

   479 	/**

   480 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobileCallSwap

   481 	 * request from the CTSY.

   482 	 *

   483 	 * It is a request call that is completed by invoking

   484 	 * CCtsyDispatcherCallback::CallbackCallControlSwapComp()

   485 	 *

   486 	 * This request should be completed when the request to swap the call has

   487 	 * been placed.

   488 	 *

   489 	 * Implementation of this interface should request that the Licensee TSY

   490 	 * swap the specified calls.  Swapping requires two calls to be active,

   491 	 * one held and one connected.  It involves switching the states of the

   492 	 * two call such that the held call becomes connected (RMobileCall::EStatusConnected)

   493 	 * and the connected call becomes held (RMobileCall::EStatusHold).

   494 	 *

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

   496 	 *

   497 	 * @param aConnectedCallId The Call ID of the connected call to swap with

   498 	 * aHeldCallId.

   499 	 *

   500 	 * @return KErrNone on success, otherwise another error code indicating the

   501 	 * failure.

   502 	 *

   503 	 * @see RMobileCall::Swap()

   504 	 */

   505 	virtual TInt HandleSwapReqL(TInt aHeldCallId, TInt aConnectedCallId) = 0;

   506 

   507 	}; // class MLtsyDispatchCallControlSwap

   508 

   509 

   510 class MLtsyDispatchCallControlLoanDataPort : public MLtsyDispatchInterface

   511 	{

   512 public:

   513 

   514 	static const TInt KLtsyDispatchCallControlLoanDataPortApiId = KDispatchCallControlFuncUnitId + 15;

   515 

   516 	/**

   517 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallLoanDataPort

   518 	 * request from the CTSY.

   519 	 *

   520 	 * Implementation of this interface should read the port name from CommDat

   521 	 * for use in a data call. This API may be adaptation specific.

   522 	 *

   523 	 * It is a sync call where the output parameters should be completed before returning

   524 	 * from this function.

   525 	 *

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

   527 	 *

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

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

   530 	 *

   531 	 * @return KErrNone on success, otherwise another error code indicating the

   532 	 * failure.

   533 	 */

   534 	virtual TInt HandleLoanDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort) = 0;

   535 

   536 	}; // class MLtsyDispatchCallControlLoanDataPort

   537 

   538 

   539 

   540 class MLtsyDispatchCallControlRecoverDataPort : public MLtsyDispatchInterface

   541 	{

   542 public:

   543 

   544 	static const TInt KLtsyDispatchCallControlRecoverDataPortApiId = KDispatchCallControlFuncUnitId + 16;

   545 

   546 	/**

   547 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallRecoverDataPort

   548 	 * request from the CTSY.

   549 	 *

   550 	 * Implementation of this interface should recover the data port loaned by a

   551 	 * previous call to

   552 	 * MLtsyDispatchCallControlLoanDataPort::HandleLoanDataPortSyncL()

   553 	 * and matches a client side call to RCall::RecoverDataPort().

   554 	 *

   555 	 * It is a sync call where the data arguments should be completed before returning.

   556 	 *

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

   558 	 *

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

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

   561 	 *

   562 	 * @return KErrNone on success, otherwise another error code indicating the

   563 	 * failure.

   564 	 */

   565 	virtual TInt HandleRecoverDataPortSyncL(TInt aCallId, RCall::TCommPort& aCommPort) = 0;

   566 

   567 	}; // class MLtsyDispatchCallControlRecoverDataPort

   568 

   569 

   570 

   571 class MLtsyDispatchCallControlStartDtmfTone : public MLtsyDispatchInterface

   572 	{

   573 public:

   574 

   575 	static const TInt KLtsyDispatchCallControlStartDtmfToneApiId = KDispatchCallControlFuncUnitId + 17;

   576 

   577 	/**

   578 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneStartDTMFTone

   579 	 * request from the CTSY.

   580 	 *

   581 	 * Implementation of this interface should send the specified DTMF tone

   582 	 * through the currently active call.

   583 	 *

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

   585 	 * will be sent.

   586 	 *

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

   588 	 *

   589 	 * @return KErrNone on success, otherwise another error code indicating the

   590 	 * failure.

   591 	 *

   592 	 * @see RMobilePhone::StartDTMFTone()

   593 	 */

   594 	virtual TInt HandleStartDtmfToneReqL(TInt aCallId, const TChar& aTone) = 0;

   595 

   596 	}; // class MLtsyDispatchCallControlStartDtmfTone

   597 

   598 

   599 

   600 

   601 class MLtsyDispatchCallControlGetActiveAlsLine : public MLtsyDispatchInterface

   602 	{

   603 public:

   604 	static const TInt KLtsyDispatchCallControlGetActiveAlsLineApiId = KDispatchCallControlFuncUnitId + 18;

   605 

   606 public:

   607 

   608 	/**

   609 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetActiveAlsLine

   610 	 * request from the CTSY.

   611 	 *

   612 	 * It is a request call that is completed by invoking

   613 	 * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()

   614 	 *

   615 	 * Implementation of this interface should retrieve the currently selected ALS line.

   616 	 *

   617 	 * @return KErrNone on success, otherwise another error code indicating the

   618 	 * failure.

   619 	 *

   620 	 * @see RMobilePhone::GetALSLine()

   621 	 */

   622 	virtual TInt HandleGetActiveAlsLineReqL() = 0;

   623 

   624 	}; // class MLtsyDispatchCallControlGetActiveAlsLine

   625 

   626 

   627 class MLtsyDispatchCallControlDialData : public MLtsyDispatchInterface

   628 	{

   629 public:

   630 	static const TInt KLtsyDispatchCallControlDialDataApiId = KDispatchCallControlFuncUnitId + 19;

   631 public:

   632 

   633 	/**

   634 	 * The CTSY Dispatcher shall invoke this function on receiving the EEtelCallDial

   635 	 * request from the CTSY when a data call is requested.

   636 	 *

   637 	 * It is a request call that is completed by invoking

   638 	 * CCtsyDispatcherCallback::CallbackCallControlDialDataComp()

   639 	 *

   640 	 * Implementation of this interface should dial the data call to the

   641 	 * specified destination. The callback should be completed when the dial

   642 	 * request has been sent to the baseband and should indicate

   643 	 * that an attempt to dial the call has been made.  The callback function is used

   644 	 * to indicate the outcome of this attempt to initiate the dialling process.

   645 	 *

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

   647 	 *

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

   649 	 * number to dial.

   650 	 *

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

   652 	 * 

   653 	 * @param aPerformFdnCheck whether or not an FDN (Fixed Dialling Number) check should be performed.

   654 	 *

   655 	 * @return KErrNone on success; KErrNotSupported if the LTSY does not

   656 	 * support handling of this request or another error code indicating the

   657 	 * failure otherwise.

   658 	 *

   659 	 * @see RCall::Dial()

   660 	 */

   661 	virtual TInt HandleDialDataReqL(const RMobilePhone::TMobileAddress& aDialledParty, const RMobileCall::TMobileDataCallParamsV1& aCallParamsV1,

   662 			TBool aPerformFdnCheck) = 0;

   663 

   664 	}; // class MLtsyDispatchCallControlDialData

   665 

   666 

   667 class MLtsyDispatchCallControlQueryIsEmergencyNumber : public MLtsyDispatchInterface

   668 	{

   669 public:

   670 	static const TInt KLtsyDispatchCallControlQueryIsEmergencyNumberApiId = KDispatchCallControlFuncUnitId + 20;

   671 public:

   672 

   673 	/**

   674 	 * The CTSY Dispatcher shall invoke this function on receiving the

   675 	 * ECustomCheckEmergencyNumberIPC request from the CTSY.

   676 	 *

   677 	 * It is a sync call where the output data arguments should be completed

   678 	 * before returning.

   679 	 *

   680 	 * Implementation of this interface should check whether the specified

   681 	 * number is an emergency number and return the result back to the caller

   682 	 * via the output parameter.

   683 	 *

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

   685 	 * if it is an emergency number or not.

   686 	 *

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

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

   689 	 *

   690 	 * @return KErrNone if the LTSY was successful in determining whether the

   691 	 * queried number is an emergency one; KErrNotSupported if the LTSY does not

   692 	 * support handling of this request or another error code indicating the

   693 	 * failure otherwise.

   694 	 */

   695 	virtual TInt HandleQueryIsEmergencyNumberSyncL(const TDesC& aNumber, TBool& aIsEmergencyNumber) = 0;

   696 

   697 	}; // class MLtsyDispatchCallControlQueryIsEmergencyNumber

   698 

   699 

   700 class MLtsyDispatchCallControlGetAlsPpSupport : public MLtsyDispatchInterface

   701 	{

   702 public:

   703 

   704 	static const TInt KLtsyDispatchCallControlGetAlsPpSupportApiId = KDispatchCallControlFuncUnitId + 21;

   705 

   706 	/**

   707 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckAlsPpSupportIPC

   708 	 * request from the CTSY.

   709 	 *

   710 	 * It is a request call that is completed by invoking

   711 	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp()

   712 	 *

   713 	 * Implementation of this interface should return check if the product profile support ALS.

   714 	 *

   715 	 * @return KErrNone on success, otherwise another error code indicating the

   716 	 * failure.

   717 	 *

   718 	 * @see RMmCustomAPI::CheckAlsPpSupport()

   719 	 */

   720 	virtual TInt HandleGetAlsPpSupportL() = 0;

   721 

   722 	}; // class MLtsyDispatchCallControlGetAlsPpSupport

   723 

   724 

   725 class MLtsyDispatchCallControlGetAlsBlockedStatus : public MLtsyDispatchInterface

   726 	{

   727 public:

   728 

   729 	static const TInt KLtsyDispatchCallControlGetAlsBlockedStatusApiId = KDispatchCallControlFuncUnitId + 22;

   730 

   731 	/**

   732 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetAlsBlockedIPC

   733 	 * request from the CTSY.

   734 	 *

   735 	 * It is a request call that is completed by invoking

   736 	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp()

   737 	 *

   738 	 * Implementation of this interface should return the blocked status of the ALS service.

   739 	 *

   740 	 * @return KErrNone on success, otherwise another error code indicating the

   741 	 * failure.

   742 	 *

   743 	 * @see RMmCustomAPI::GetAlsBlocked()

   744 	 */

   745 	virtual TInt HandleGetAlsBlockedStatusL() = 0;

   746 

   747 	}; // class MLtsyDispatchCallControlGetAlsBlockedStatus

   748 

   749 

   750 class MLtsyDispatchCallControlSetAlsBlocked : public MLtsyDispatchInterface

   751 	{

   752 public:

   753 

   754 	static const TInt KLtsyDispatchCallControlSetAlsBlockedApiId = KDispatchCallControlFuncUnitId + 23;

   755 

   756 	/**

   757 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomSetAlsBlockedIPC

   758 	 * request from the CTSY.

   759 	 *

   760 	 * It is a request call that is completed by invoking

   761 	 * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp()

   762 	 *

   763 	 * Implementation of this interface should set the ALS blocked status.

   764 	 *

   765      * @param aBlocked RMmCustomAPI::EDeactivateBlock when the ALS block needs to be deactivated,

   766      *                 RMmCustomAPI::EActivateBlock when the ALS block needs to be activated.

   767      *

   768 	 * @return KErrNone on success, otherwise another error code indicating the

   769 	 * failure.

   770 	 *

   771 	 * @see RMmCustomAPI::SetAlsBlocked()

   772 	 */

   773 	virtual TInt HandleSetAlsBlockedL(RMmCustomAPI::TSetAlsBlock aBlocked) = 0;

   774 

   775 	}; // class MLtsyDispatchCallControlSetAlsBlocked

   776 

   777 

   778 class MLtsyDispatchCallControlGetLifeTime : public MLtsyDispatchInterface

   779 	{

   780 public:

   781 

   782 	static const TInt KLtsyDispatchCallControlGetLifeTimeApiId = KDispatchCallControlFuncUnitId + 24;

   783 

   784 	/**

   785 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetLifeTimeIPC

   786 	 * request from the CTSY.

   787 	 *

   788 	 * It is a request call that is completed by invoking one of the 

   789 	 * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp()

   790 	 *

   791 	 * Implementation of this interface should return the lifetime of the phone. The lifetime

   792      * information includes the manufacturing date of the phone and/or the total amount of air time used

   793      * from the manufacturing date until the call to this method. Calling this method does not reset any data. 

   794 	 *

   795 	 * @return KErrNone on success, otherwise another error code indicating the

   796 	 * failure.

   797 	 *

   798 	 * @see RMmCustomAPI::GetLifeTime()

   799 	 */

   800 	virtual TInt HandleGetLifeTimeL() = 0;

   801 

   802 	}; // class MLtsyDispatchCallControlGetLifeTimeStatus

   803 

   804 

   805 class MLtsyDispatchCallControlTerminateErrorCall : public MLtsyDispatchInterface

   806 	{

   807 public:

   808 

   809 	static const TInt KLtsyDispatchCallControlTerminateErrorCallApiId = KDispatchCallControlFuncUnitId + 25;

   810 

   811 	/**

   812 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomTerminateCallIPC

   813 	 * request from the CTSY with a valid call id.

   814 	 *

   815 	 * It is a request call that is completed by invoking

   816 	 * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp()

   817 	 *

   818 	 * Implementation of this interface should terminate the call with an error.

   819 	 *

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

   821      *

   822 	 * @return KErrNone on success, otherwise another error code indicating the

   823 	 * failure.

   824 	 *

   825 	 * @see RMmCustomAPI::TerminateCall()

   826 	 */

   827 	virtual TInt HandleTerminateErrorCallL(TInt aCallId) = 0;

   828 

   829 	}; // class MLtsyDispatchCallControlTerminateErrorCall

   830 

   831 

   832 class MLtsyDispatchCallControlTerminateAllCalls : public MLtsyDispatchInterface

   833 	{

   834 public:

   835 

   836 	static const TInt KLtsyDispatchCallControlTerminateAllCallsApiId = KDispatchCallControlFuncUnitId + 26;

   837 

   838 	/**

   839 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomTerminateCallIPC

   840 	 * request from the CTSY with an invalid call id.

   841 	 *

   842 	 * It is a request call that is completed by invoking

   843 	 * CCtsyDispatcherCallback::CallbackCallControlTerminateAllCallsComp()

   844 	 *

   845 	 * Implementation of this interface should terminate all the active, connecting and held calls.

   846 	 *

   847 	 * @return KErrNone on success, otherwise another error code indicating the

   848 	 * failure.

   849 	 *

   850 	 * @see RMmCustomAPI::TerminateCall()

   851 	 */

   852 	virtual TInt HandleTerminateAllCallsL() = 0;

   853 

   854 	}; // class MLtsyDispatchCallControlTerminateAllCalls

   855 

   856 

   857 class MLtsyDispatchCallControlGetCallForwardingIndicator : public MLtsyDispatchInterface

   858 	{

   859 public:

   860 

   861 	static const TInt KLtsyDispatchCallControlGetCallForwardingIndicatorApiId = KDispatchCallControlFuncUnitId + 27;

   862 

   863 	/**

   864 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetIccCallForwardingStatusIPC

   865 	 * request from the CTSY.

   866 	 *

   867 	 * It is a request call that is completed by invoking one of the 

   868 	 * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp()

   869 	 *

   870 	 * Implementation of this interface should return the call forwarding indicator from the network.

   871 	 *

   872 	 * @return KErrNone on success, otherwise another error code indicating the

   873 	 * failure.

   874 	 *

   875 	 * @see RMmCustomAPI::GetIccCallForwardingIndicatorStatus()

   876 	 */

   877 	virtual TInt HandleGetCallForwardingIndicatorL() = 0;

   878 

   879 	}; // class MLtsyDispatchCallControlGetCallForwardingIndicator

   880 

   881 class MLtsyDispatchCallControlUpdateLifeTimer : public MLtsyDispatchInterface

   882 	{

   883 public:

   884 	static const TInt KLtsyDispatchCallControlUpdateLifeTimerApiId = KDispatchCallControlFuncUnitId + 28;

   885 public:

   886 

   887 	/**

   888 	 * The CTSY Dispatcher shall invoke this function on receiving the

   889 	 * ECtsyUpdateLifeTimeReq request from the CTSY.

   890 	 *

   891 	 * It is a request call that is completed by invoking

   892 	 * CCtsyDispatcherCallback::CallbackCallControlUpdateLifeTimerComp()

   893 	 *

   894 	 * Implementation of this interface can accumulate the number of seconds that

   895 	 * have elapsed since a call started. By initialising a variable in the LTSY when a 

   896 	 * call is dialed, then adding the value contained in aDuration to this variable 

   897 	 * it is possible to track the duration of a call.

   898 	 * 

   899 	 * HandleUpdateLifeTimerReqL is usually invoked every 10 seconds.

   900 	 *

   901 	 * @param aDuration The number of seconds that have elapsed since the last time

   902 	 * this interface was invoked (or since the start of the call if the first invocation).

   903 	 *

   904 	 * @return KErrNone if the LTSY was successful; KErrNotSupported if the LTSY does not

   905 	 * support handling of this request or another error code indicating the

   906 	 * failure otherwise.

   907 	 */

   908 	virtual TInt HandleUpdateLifeTimerReqL(TUint32 aDuration) = 0;

   909 

   910 	}; // class MLtsyDispatchCallControlUpdateLifeTimer

   911 

   912 

   913 

   914 #endif /*MLTSYDISPATCHCALLCONTROLINTERFACE_H_*/