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 	static const TInt KLtsyDispatchCallControlSingleSwapApiId = KDispatchCallControlFuncUnitId + 29;

   479 

   480 	/**

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

   482 	 * request from the CTSY.

   483 	 *

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

   485 	 * CCtsyDispatcherCallback::CallbackCallControlSwapComp()

   486 	 *

   487 	 * This request should be completed when the request to swap two calls has

   488 	 * been placed. One is held and the other connected. The held call becomes connected

   489 	 * (RMobileCall::EStatusConnected) and the connected call becomes held 

   490 	 * (RMobileCall::EStatusHold).

   491 	 *

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

   493 	 * swap the specified calls. Swapping is allowed for one or two active calls.

   494 	 *

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

   496 	 *

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

   498 	 * failure.

   499 	 *

   500 	 * @see RMobileCall::Swap()

   501 	 */

   502 	virtual TInt HandleSwapReqL(TInt aCallId, TInt aSecondCallId) = 0;

   503 

   504 	/**

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

   506 	 * request, for a single call, from the CTSY.

   507 	 *

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

   509 	 * CCtsyDispatcherCallback::CallbackCallControlSwapComp()

   510 	 *

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

   512 	 * been placed.

   513 	 *

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

   515 	 * swap the specified call. The state of the call will be swapped from held to connected 

   516 	 * (or visa versa)

   517 	 *

   518 	 * @param aCallId The Call ID of the single call to swap.

   519 	 *

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

   521 	 * failure.

   522 	 *

   523 	 * @see RMobileCall::Swap()

   524 	 */

   525 	virtual TInt HandleSwapReqL(TInt aCallId) = 0;

   526 

   527 	}; // class MLtsyDispatchCallControlSwap

   528 

   529 

   530 	

   531 class MLtsyDispatchCallControlLoanDataPort : public MLtsyDispatchInterface

   532 	{

   533 public:

   534 

   535 	static const TInt KLtsyDispatchCallControlLoanDataPortApiId = KDispatchCallControlFuncUnitId + 15;

   536 

   537 	/**

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

   539 	 * request from the CTSY.

   540 	 *

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

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

   543 	 *

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

   545 	 * from this function.

   546 	 *

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

   548 	 *

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

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

   551 	 *

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

   553 	 * failure.

   554 	 */

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

   556 

   557 	}; // class MLtsyDispatchCallControlLoanDataPort

   558 

   559 

   560 

   561 class MLtsyDispatchCallControlRecoverDataPort : public MLtsyDispatchInterface

   562 	{

   563 public:

   564 

   565 	static const TInt KLtsyDispatchCallControlRecoverDataPortApiId = KDispatchCallControlFuncUnitId + 16;

   566 

   567 	/**

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

   569 	 * request from the CTSY.

   570 	 *

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

   572 	 * previous call to

   573 	 * MLtsyDispatchCallControlLoanDataPort::HandleLoanDataPortSyncL()

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

   575 	 *

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

   577 	 *

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

   579 	 *

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

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

   582 	 *

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

   584 	 * failure.

   585 	 */

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

   587 

   588 	}; // class MLtsyDispatchCallControlRecoverDataPort

   589 

   590 

   591 

   592 class MLtsyDispatchCallControlStartDtmfTone : public MLtsyDispatchInterface

   593 	{

   594 public:

   595 

   596 	static const TInt KLtsyDispatchCallControlStartDtmfToneApiId = KDispatchCallControlFuncUnitId + 17;

   597 

   598 	/**

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

   600 	 * request from the CTSY.

   601 	 *

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

   603 	 * through the currently active call.

   604 	 *

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

   606 	 * will be sent.

   607 	 *

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

   609 	 *

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

   611 	 * failure.

   612 	 *

   613 	 * @see RMobilePhone::StartDTMFTone()

   614 	 */

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

   616 

   617 	}; // class MLtsyDispatchCallControlStartDtmfTone

   618 

   619 

   620 

   621 

   622 class MLtsyDispatchCallControlGetActiveAlsLine : public MLtsyDispatchInterface

   623 	{

   624 public:

   625 	static const TInt KLtsyDispatchCallControlGetActiveAlsLineApiId = KDispatchCallControlFuncUnitId + 18;

   626 

   627 public:

   628 

   629 	/**

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

   631 	 * request from the CTSY.

   632 	 *

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

   634 	 * CCtsyDispatcherCallback::CallbackCallControlGetActiveAlsLineComp()

   635 	 *

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

   637 	 *

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

   639 	 * failure.

   640 	 *

   641 	 * @see RMobilePhone::GetALSLine()

   642 	 */

   643 	virtual TInt HandleGetActiveAlsLineReqL() = 0;

   644 

   645 	}; // class MLtsyDispatchCallControlGetActiveAlsLine

   646 

   647 

   648 class MLtsyDispatchCallControlDialData : public MLtsyDispatchInterface

   649 	{

   650 public:

   651 	static const TInt KLtsyDispatchCallControlDialDataApiId = KDispatchCallControlFuncUnitId + 19;

   652 public:

   653 

   654 	/**

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

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

   657 	 *

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

   659 	 * CCtsyDispatcherCallback::CallbackCallControlDialDataComp()

   660 	 *

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

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

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

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

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

   666 	 *

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

   668 	 *

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

   670 	 * number to dial.

   671 	 *

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

   673 	 * 

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

   675 	 *

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

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

   678 	 * failure otherwise.

   679 	 *

   680 	 * @see RCall::Dial()

   681 	 */

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

   683 			TBool aPerformFdnCheck) = 0;

   684 

   685 	}; // class MLtsyDispatchCallControlDialData

   686 

   687 

   688 class MLtsyDispatchCallControlQueryIsEmergencyNumber : public MLtsyDispatchInterface

   689 	{

   690 public:

   691 	static const TInt KLtsyDispatchCallControlQueryIsEmergencyNumberApiId = KDispatchCallControlFuncUnitId + 20;

   692 public:

   693 

   694 	/**

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

   696 	 * ECustomCheckEmergencyNumberIPC request from the CTSY.

   697 	 *

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

   699 	 * before returning.

   700 	 *

   701 	 * Implementation of this interface should check whether the specified

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

   703 	 * via the output parameter.

   704 	 *

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

   706 	 * if it is an emergency number or not.

   707 	 *

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

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

   710 	 *

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

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

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

   714 	 * failure otherwise.

   715 	 */

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

   717 

   718 	}; // class MLtsyDispatchCallControlQueryIsEmergencyNumber

   719 

   720 

   721 class MLtsyDispatchCallControlGetAlsPpSupport : public MLtsyDispatchInterface

   722 	{

   723 public:

   724 

   725 	static const TInt KLtsyDispatchCallControlGetAlsPpSupportApiId = KDispatchCallControlFuncUnitId + 21;

   726 

   727 	/**

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

   729 	 * request from the CTSY.

   730 	 *

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

   732 	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsPpSupportComp()

   733 	 *

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

   735 	 *

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

   737 	 * failure.

   738 	 *

   739 	 * @see RMmCustomAPI::CheckAlsPpSupport()

   740 	 */

   741 	virtual TInt HandleGetAlsPpSupportL() = 0;

   742 

   743 	}; // class MLtsyDispatchCallControlGetAlsPpSupport

   744 

   745 

   746 class MLtsyDispatchCallControlGetAlsBlockedStatus : public MLtsyDispatchInterface

   747 	{

   748 public:

   749 

   750 	static const TInt KLtsyDispatchCallControlGetAlsBlockedStatusApiId = KDispatchCallControlFuncUnitId + 22;

   751 

   752 	/**

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

   754 	 * request from the CTSY.

   755 	 *

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

   757 	 * CCtsyDispatcherCallback::CallbackCallControlGetAlsBlockedStatusComp()

   758 	 *

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

   760 	 *

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

   762 	 * failure.

   763 	 *

   764 	 * @see RMmCustomAPI::GetAlsBlocked()

   765 	 */

   766 	virtual TInt HandleGetAlsBlockedStatusL() = 0;

   767 

   768 	}; // class MLtsyDispatchCallControlGetAlsBlockedStatus

   769 

   770 

   771 class MLtsyDispatchCallControlSetAlsBlocked : public MLtsyDispatchInterface

   772 	{

   773 public:

   774 

   775 	static const TInt KLtsyDispatchCallControlSetAlsBlockedApiId = KDispatchCallControlFuncUnitId + 23;

   776 

   777 	/**

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

   779 	 * request from the CTSY.

   780 	 *

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

   782 	 * CCtsyDispatcherCallback::CallbackCallControlSetAlsBlockedComp()

   783 	 *

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

   785 	 *

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

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

   788      *

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

   790 	 * failure.

   791 	 *

   792 	 * @see RMmCustomAPI::SetAlsBlocked()

   793 	 */

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

   795 

   796 	}; // class MLtsyDispatchCallControlSetAlsBlocked

   797 

   798 

   799 class MLtsyDispatchCallControlGetLifeTime : public MLtsyDispatchInterface

   800 	{

   801 public:

   802 

   803 	static const TInt KLtsyDispatchCallControlGetLifeTimeApiId = KDispatchCallControlFuncUnitId + 24;

   804 

   805 	/**

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

   807 	 * request from the CTSY.

   808 	 *

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

   810 	 * CCtsyDispatcherCallback::CallbackCallControlGetLifeTimeComp()

   811 	 *

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

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

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

   815 	 *

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

   817 	 * failure.

   818 	 *

   819 	 * @see RMmCustomAPI::GetLifeTime()

   820 	 */

   821 	virtual TInt HandleGetLifeTimeL() = 0;

   822 

   823 	}; // class MLtsyDispatchCallControlGetLifeTimeStatus

   824 

   825 

   826 class MLtsyDispatchCallControlTerminateErrorCall : public MLtsyDispatchInterface

   827 	{

   828 public:

   829 

   830 	static const TInt KLtsyDispatchCallControlTerminateErrorCallApiId = KDispatchCallControlFuncUnitId + 25;

   831 

   832 	/**

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

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

   835 	 *

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

   837 	 * CCtsyDispatcherCallback::CallbackCallControlTerminateErrorCallComp()

   838 	 *

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

   840 	 *

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

   842      *

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

   844 	 * failure.

   845 	 *

   846 	 * @see RMmCustomAPI::TerminateCall()

   847 	 */

   848 	virtual TInt HandleTerminateErrorCallL(TInt aCallId) = 0;

   849 

   850 	}; // class MLtsyDispatchCallControlTerminateErrorCall

   851 

   852 

   853 class MLtsyDispatchCallControlTerminateAllCalls : public MLtsyDispatchInterface

   854 	{

   855 public:

   856 

   857 	static const TInt KLtsyDispatchCallControlTerminateAllCallsApiId = KDispatchCallControlFuncUnitId + 26;

   858 

   859 	/**

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

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

   862 	 *

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

   864 	 * CCtsyDispatcherCallback::CallbackCallControlTerminateAllCallsComp()

   865 	 *

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

   867 	 *

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

   869 	 * failure.

   870 	 *

   871 	 * @see RMmCustomAPI::TerminateCall()

   872 	 */

   873 	virtual TInt HandleTerminateAllCallsL() = 0;

   874 

   875 	}; // class MLtsyDispatchCallControlTerminateAllCalls

   876 

   877 

   878 class MLtsyDispatchCallControlGetCallForwardingIndicator : public MLtsyDispatchInterface

   879 	{

   880 public:

   881 

   882 	static const TInt KLtsyDispatchCallControlGetCallForwardingIndicatorApiId = KDispatchCallControlFuncUnitId + 27;

   883 

   884 	/**

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

   886 	 * request from the CTSY.

   887 	 *

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

   889 	 * CCtsyDispatcherCallback::CallbackCallControlGetCallForwardingIndicatorComp()

   890 	 *

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

   892 	 *

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

   894 	 * failure.

   895 	 *

   896 	 * @see RMmCustomAPI::GetIccCallForwardingIndicatorStatus()

   897 	 */

   898 	virtual TInt HandleGetCallForwardingIndicatorL() = 0;

   899 

   900 	}; // class MLtsyDispatchCallControlGetCallForwardingIndicator

   901 

   902 class MLtsyDispatchCallControlUpdateLifeTimer : public MLtsyDispatchInterface

   903 	{

   904 public:

   905 	static const TInt KLtsyDispatchCallControlUpdateLifeTimerApiId = KDispatchCallControlFuncUnitId + 28;

   906 public:

   907 

   908 	/**

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

   910 	 * ECtsyUpdateLifeTimeReq request from the CTSY.

   911 	 *

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

   913 	 * CCtsyDispatcherCallback::CallbackCallControlUpdateLifeTimerComp()

   914 	 *

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

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

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

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

   919 	 * 

   920 	 * HandleUpdateLifeTimerReqL is usually invoked every 10 seconds.

   921 	 *

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

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

   924 	 *

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

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

   927 	 * failure otherwise.

   928 	 */

   929 	virtual TInt HandleUpdateLifeTimerReqL(TUint32 aDuration) = 0;

   930 

   931 	}; // class MLtsyDispatchCallControlUpdateLifeTimer

   932 

   933 	

   934 // Note: A static constant has been defined in MLtsyDispatchCallControlSwap (abbove) with the highest Id 

   935 // in this file... "KLtsyDispatchCallControlSingleSwapApiId = KDispatchCallControlFuncUnitId + 29"

   936 // If adding a new Id it must be greater than KDispatchCallControlFuncUnitId + 29.

   937 

   938 #endif /*MLTSYDISPATCHCALLCONTROLINTERFACE_H_*/