1 // Copyright (c) 1997-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 // Contains method implementations for RMobileCall subsession

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include <etelext.h>

    23 #include <etelmm.h>

    24 #include <et_clsvr.h>

    25 #include "mm_hold.h"

    26 

    27 /************************************************************************/

    28 //

    29 //  RMobileCall

    30 //

    31 /************************************************************************/

    32 

    33 EXPORT_C RMobileCall::RMobileCall()

    34 	: iMmPtrHolder(NULL)

    35 /** Default constructor, and is present only to support virtual 

    36 function table export.

    37 This member is internal and not intended use. */

    38 	{

    39 	}

    40 

    41 EXPORT_C void RMobileCall::ConstructL()

    42 	{

    43 	RCall::ConstructL();

    44 	__ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));

    45 	iMmPtrHolder = CMobileCallPtrHolder::NewL(CMobileCallPtrHolder::EMaxNumberCallPtrSlots,CMobileCallPtrHolder::EMaxNumberCallPtrCSlots);

    46 	}

    47 

    48 EXPORT_C void RMobileCall::Destruct()

    49 	{

    50 	RCall::Destruct();

    51 	delete iMmPtrHolder;

    52 	iMmPtrHolder = NULL;

    53 	}

    54 

    55 EXPORT_C RMobileCall::TMobileCallParamsV1::TMobileCallParamsV1() 

    56 :	RCall::TCallParams(),

    57 	iIdRestrict(EIdRestrictDefault), 

    58 	iAutoRedial(EFalse)

    59 	{

    60 	iCug.iExplicitInvoke = EFalse;

    61 	iCug.iCugIndex = 0;

    62 	iCug.iSuppressOA = EFalse;

    63 	iCug.iSuppressPrefCug = EFalse;

    64 	iExtensionId = KETelMobileCallParamsV1; //overwrite iExtensionId setup in RCall::TCallParams c'tor

    65 	}

    66 

    67 EXPORT_C RMobileCall::TMobileCallParamsV2::TMobileCallParamsV2() 

    68 :	TMobileCallParamsV1(), 

    69  	iBearerMode(EMulticallNotSupported)

    70 	/** Default constructor. The bearer mode is set to EMulticallNotSupported. */

    71  	{

    72  	iExtensionId = KETelMobileCallParamsV2; //overwrite iExtensionId setup in RCall::TCallParams c'tor

    73  	}

    74 

    75 EXPORT_C RMobileCall::TMobileCallParamsV7::TMobileCallParamsV7()

    76 :	TMobileCallParamsV2(),

    77 	iCallParamOrigin(EOriginatorUnknown),

    78 	iBCRepeatIndicator(EBCAlternateMode)

    79 	{

    80 	iExtensionId = KETelMobileCallParamsV7;

    81 	iIconId.iQualifier = EIconQualifierNotSet;

    82 	iIconId.iIdentifier = 0;

    83 	}

    84 

    85 

    86 /***********************************************************************************/

    87 //

    88 // MobileDataCall Functional Unit

    89 //

    90 /***********************************************************************************/

    91 

    92 EXPORT_C RMobileCall::TMobileCallCugV1::TMobileCallCugV1() :

    93 	iExplicitInvoke(EFalse), 

    94 	iCugIndex(0), 

    95 	iSuppressOA(EFalse), 

    96 	iSuppressPrefCug(EFalse)

    97 	/** Default constructor, and is present only to support virtual 

    98 	function table export. */

    99 	{

   100 	iExtensionId = KETelExtMultimodeV1;

   101 	}

   102 

   103 EXPORT_C RMobileCall::TMobileCallDataCapsV1::TMobileCallDataCapsV1() : 

   104 	iSpeedCaps(0), 

   105 	iProtocolCaps(0), 

   106 	iServiceCaps(0), 

   107 	iQoSCaps(0), 

   108 	iHscsdSupport(EFalse),

   109 	iMClass(0), 

   110 	iMaxRxTimeSlots(0), 

   111 	iMaxTxTimeSlots(0), 

   112 	iTotalRxTxTimeSlots(0), 

   113 	iCodingCaps(0),

   114 	iAsymmetryCaps(0),

   115 	iUserInitUpgrade(EFalse),

   116 	iRLPVersionCaps(0),

   117 	iV42bisCaps(0)

   118 	/** Default constructor, and is present only to support virtual 

   119 	function table export. */

   120 	{

   121 	iExtensionId = KETelExtMultimodeV1;

   122 	}

   123 

   124 EXPORT_C TInt RMobileCall::GetMobileDataCallCaps(TDes8& aCaps) const

   125 /** Gets the current data call capabilities. The data capabilities 

   126 provide clients with knowledge of which data call parameter values they can 

   127 then set-up or negotiate for this call.

   128 

   129 @param aCaps On completion, contains the current snapshot of the call's circuit 

   130 switched data capabilities. The capabilities will be placed in an instance 

   131 of the TMobileCallDataCapsV1Pckg.

   132 @return KErrNone if the function member was successful, KErrNotSupported if 

   133 call does not support circuit switched data, KErrNotFound if this 

   134 call is not a data call. 

   135 @capability None

   136 */

   137 	{

   138 	return Get(EMobileCallGetMobileDataCallCaps,aCaps);

   139 	}

   140 

   141 EXPORT_C void RMobileCall::NotifyMobileDataCallCapsChange(TRequestStatus& aReqStatus, TDes8& aCaps) const

   142 /** Allows clients to be notified of a change in the call's data capabilities.

   143 

   144 The data capabilities of a call can change if the phone changes mode before 

   145 the call moves out of the idle state.

   146 

   147 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyMobileDataCallCapsChange) 

   148 to cancel a previously placed asynchronous NotifyMobileDataCallCapsChange() 

   149 request.

   150 

   151 @param aReqStatus KErrNone if successful, otherwise another of the system-wide 

   152 error codes.

   153 @param aCaps On completion, contains the current snapshot of the call's circuit 

   154 switched data capabilities. The new capabilities will be placed in an instance 

   155 of the TMobileCallDataCapsV1 type. This class will have been packaged into 

   156 a TMobileCallDataCapsV1Pckg. 

   157 @capability None

   158 */

   159 	{

   160 	Get(EMobileCallNotifyMobileDataCallCapsChange,aReqStatus,aCaps);

   161 	}

   162 

   163 EXPORT_C RMobileCall::TMobileDataRLPRangesV1::TMobileDataRLPRangesV1() :

   164 	iIWSMax(0),

   165 	iIWSMin(0),

   166 	iMWSMax(0),

   167 	iMWSMin(0),

   168 	iT1Max(0),

   169 	iT1Min(0),

   170 	iN2Max(0),

   171 	iN2Min(0),

   172 	iT4Max(0),

   173 	iT4Min(0)

   174 	/** Default constructor, and is present only to support virtual 

   175 	function table export. */

   176 	{

   177 	iExtensionId = KETelExtMultimodeV1;

   178 	}

   179 

   180 EXPORT_C void RMobileCall::GetMobileDataCallRLPRange(TRequestStatus& aReqStatus, TInt aRLPVersion, TDes8& aRLPRange) const

   181 /** Gets the minimum and maximum RLP parameter ranges supported 

   182 by the phone for the specified RLP version.

   183 

   184 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallGetMobileDataCallRLPRange)with 

   185 to cancel a previously placed asynchronous GetMobileDataCallRLPRange() request.

   186 

   187 @param aReqStatus KErrNone if the function member was successful, KErrNotSupported 

   188 if the phone does not support the RLP version interrogated.

   189 @param aRLPVersion The requested RLP version.

   190 @param aRLPRange On completion, a descriptor that will contain the RLP parameter 

   191 ranges. The capabilities will be packaged into a TMobileDataRLPRangesV1Pckg. 

   192 @capability NetworkControl

   193 @capability ReadDeviceData

   194 

   195 @see TMobileDataRLPRangesV1Pckg

   196 @see TMobileDataRLPRangesV1

   197 */

   198 	{

   199 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   200 

   201 	iMmPtrHolder->iRLPVersion = aRLPVersion;

   202 	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot1GetMobileDataCallRLPRange, iMmPtrHolder->iRLPVersion);

   203 

   204 	SetAndGet(EMobileCallGetMobileDataCallRLPRange, aReqStatus, ptr1, aRLPRange);

   205 	}

   206 

   207 EXPORT_C RMobileCall::TMobileDataCallParamsV1::TMobileDataCallParamsV1() 

   208 :	TMobileCallParamsV1(),

   209 	iService(EServiceUnspecified),

   210 	iSpeed(ESpeedUnspecified), 

   211 	iProtocol(EProtocolUnspecified), 

   212 	iQoS(EQoSUnspecified),

   213 	iRLPVersion(ERLPNotRequested),

   214 	iModemToMSWindowSize(0),

   215 	iMSToModemWindowSize(0),

   216 	iAckTimer(0),

   217 	iRetransmissionAttempts(0),

   218 	iResequencingPeriod(0),

   219 	iV42bisReq(EV42bisNeitherDirection),

   220 	iV42bisCodewordsNum(0),

   221 	iV42bisMaxStringLength(0),

   222 	iUseEdge(0)

   223 /**

   224 Default constructor, and is present only to support virtual 

   225 function table export. 

   226 */

   227 	{

   228 	iExtensionId = KETelMobileDataCallParamsV1; //overwrite iExtensionId setup in TMobileCallParamsV1 c'tor

   229 	}

   230 

   231 EXPORT_C RMobileCall::TMobileDataCallParamsV2::TMobileDataCallParamsV2() 

   232 :	TMobileDataCallParamsV1(),

   233 	iBearerMode(EMulticallNotSupported)

   234 /** Default constructor. The bearer mode is set to EMulticallNotSupported. */

   235 	{

   236 	iExtensionId = KETelMobileDataCallParamsV2; //overwrite iExtensionId setup in TMobileCallParamsV2 c'tor

   237 	}

   238 

   239 EXPORT_C RMobileCall::TMobileDataCallParamsV8::TMobileDataCallParamsV8() 

   240 :	TMobileDataCallParamsV2(),

   241 	iCallParamOrigin(EOriginatorUnknown),

   242 	iBCRepeatIndicator(EBCAlternateMode)

   243 /** Default constructor. The call origin is initialized to EOriginatorUnknown. */

   244 	{

   245 	iExtensionId = KETelMobileDataCallParamsV8; 

   246 	iIconId.iQualifier = EIconQualifierNotSet;

   247 	iIconId.iIdentifier = 0;

   248 	}

   249 

   250 EXPORT_C RMobileCall::TMobileHscsdCallParamsV1::TMobileHscsdCallParamsV1() 

   251 :	TMobileDataCallParamsV1(),

   252 	iWantedAiur(EAiurBpsUnspecified),

   253 	iWantedRxTimeSlots(0), 

   254 	iMaxTimeSlots(0), 

   255 	iCodings(0),

   256 	iAsymmetry(EAsymmetryNoPreference),

   257 	iUserInitUpgrade(EFalse)

   258 /** Default constructor, and is present only to support virtual 

   259 function table export. */

   260 	{

   261 	iExtensionId = KETelMobileHscsdCallParamsV1; //overwrite iExtensionId setup in TMobileDataCallParamsV1 c'tor

   262 	}

   263 	

   264 

   265 EXPORT_C RMobileCall::TMobileHscsdCallParamsV2::TMobileHscsdCallParamsV2() 

   266 :	TMobileHscsdCallParamsV1(),

   267 	iBearerMode(EMulticallNotSupported)

   268 /** Default constructor. The bearer mode defaults to EMulticallNotSupported. */

   269 	{

   270 	iExtensionId = KETelMobileHscsdCallParamsV2; //overwrite iExtensionId setup in TMobileDataCallParamsV2 c'tor

   271 	}

   272 

   273 EXPORT_C RMobileCall::TMobileHscsdCallParamsV7::TMobileHscsdCallParamsV7() 

   274 :	TMobileHscsdCallParamsV2(),

   275 	iCallParamOrigin(EOriginatorUnknown)

   276 /** Default constructor. The call origin is set to EOriginatorUnknown by default. */

   277 	{

   278 	iExtensionId = KETelMobileHscsdCallParamsV7;

   279 	iIconId.iQualifier = EIconQualifierNotSet;

   280 	iIconId.iIdentifier = 0;

   281 	}

   282 EXPORT_C RMobileCall::TMobileHscsdCallParamsV8::TMobileHscsdCallParamsV8() 

   283 :	TMobileHscsdCallParamsV7(),

   284 	iBCRepeatIndicator(EBCAlternateMode)

   285 /** Default constructor. The BC Repeat Indicator is initialized to EBCAlternateMode. */

   286 	{

   287 	iExtensionId = KETelMobileHscsdCallParamsV8; 

   288 	}

   289 EXPORT_C void RMobileCall::SetDynamicHscsdParams(TRequestStatus& aReqStatus, TMobileCallAiur aAiur, TInt aRxTimeslots) const

   290 /** Sets the call's dynamic HSCSD parameters.

   291 

   292 This request can be used before call set-up starts or during call connection. 

   293 If the call is not a HSCSD call then KErrNotSupported is returned.

   294 

   295 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallSetDynamicHscsdParams) 

   296 to cancel a previously placed asynchronous SetDynamicHscsdParams() request.

   297 

   298 @param aReqStatus KErrNone if the function member was successful, KErrNotSupported 

   299 if the phone does not support the RLP version interrogated.

   300 @param aAiur Wanted air interface user rate.

   301 @param aRxTimeslots Wanted number of receive (downlink) timeslots. 

   302 @capability NetworkServices

   303 */

   304 	{

   305 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   306 

   307 	iMmPtrHolder->iAiur = aAiur;

   308 	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot1SetDynamicHscsdParams, iMmPtrHolder->iAiur);

   309 

   310 	iMmPtrHolder->iRxTimeslots = aRxTimeslots;

   311 	TPtrC8& ptr2=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot2SetDynamicHscsdParams, iMmPtrHolder->iRxTimeslots);

   312 

   313 	Set(EMobileCallSetDynamicHscsdParams,aReqStatus,ptr1,ptr2);

   314 	}

   315 

   316 EXPORT_C RMobileCall::TMobileCallHscsdInfoV1::TMobileCallHscsdInfoV1() : 

   317 	iAiur(EAiurBpsUnspecified), 

   318 	iRxTimeSlots(0), 

   319 	iTxTimeSlots(0), 

   320 	iCodings(ETchCodingUnspecified)

   321 /** Default constructor, and is present only to support virtual 

   322 function table export. */

   323 	{

   324 	iExtensionId = KETelExtMultimodeV1;

   325 	}

   326 

   327 EXPORT_C RMobileCall::TMobileCallHscsdInfoV7::TMobileCallHscsdInfoV7() : 

   328 	iCallParamOrigin(EOriginatorUnknown)

   329 /** Default constructor, and is present only to support virtual 

   330 function table export. */

   331 	{

   332 	iExtensionId = KEtelExtMultimodeV7;

   333 	}

   334 EXPORT_C RMobileCall::TMobileCallHscsdInfoV8::TMobileCallHscsdInfoV8() 

   335 :	iBCRepeatIndicator(EBCAlternateMode)

   336 /** Default constructor. The BC Repeat Indicator is initialized to EBCAlternateMode. */

   337 	{

   338 	iExtensionId = KEtelExtMultimodeV8; 

   339 	}

   340 

   341 EXPORT_C TInt RMobileCall::GetCurrentHscsdInfo(TDes8& aHSCSDInfo) const

   342 /** Gets the current values of the HSCSD parameters of an 

   343 active mobile HSCSD call.

   344 

   345 @see TMobileCallHscsdInfoV1

   346 @see TMobileCallHscsdInfoV7

   347 

   348 @param aHSCSDInfo A descriptor that will contain the retrieved HSCSD information.

   349 

   350 @return KErrNone if HSCSD information successfully retrieved. 

   351 @return KErrEtelCallNotActive if call is not an active HSCSD call

   352 @return KErrNotSupported if call does not support HSCSD

   353 

   354 @capability None

   355 */

   356 	{

   357 	return Get(EMobileCallGetCurrentHscsdInfo,aHSCSDInfo);

   358 	}

   359 

   360 EXPORT_C void RMobileCall::NotifyHscsdInfoChange(TRequestStatus& aReqStatus, TDes8& aHSCSDInfo) const

   361 /** This notification completes when the mobile call's HSCSD parameters change.

   362 

   363 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyHscsdInfoChange)to 

   364 cancel a previously placed asynchronous NotifyHscsdInfoChange() request.

   365 

   366 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   367 the system-wide error codes.

   368 @param aHSCSDInfo A descriptor that will contain the new HSCSD information 

   369 @capability None

   370 */

   371 	{

   372 	Get(EMobileCallNotifyHscsdInfoChange,aReqStatus,aHSCSDInfo);			

   373 	}

   374 

   375 /***********************************************************************************/

   376 //

   377 // MobileMultimediaCall functional unit

   378 //

   379 /***********************************************************************************/

   380 

   381 EXPORT_C void RMobileCall::NotifyVoiceFallback(TRequestStatus& aReqStatus, TName& aCallName) const

   382 /** Notifies the client if a Multimedia call falls back to 

   383 a voice call due to inability in network or terminating end to comply with 

   384 the Multimedia request.

   385 

   386 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyVoiceFallback) 

   387 to cancel a previously placed asynchronous NotifyVoiceFallback() request.

   388 

   389 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   390 the system-wide error codes.

   391 @param aCallName On Completion, contains the name of a new voice call object 

   392 created by the TSY. 

   393 @capability None

   394 */

   395 	{

   396 	Get(EMobileCallNotifyVoiceFallback, aReqStatus, aCallName);

   397 	}

   398 

   399 /***********************************************************************************/

   400 //

   401 // MobileAlternatingCall functional unit

   402 //

   403 /***********************************************************************************/

   404 

   405 

   406 EXPORT_C void RMobileCall::SwitchAlternatingCall(TRequestStatus& aReqStatus) const

   407 /** Switches an alternating call to its opposite call mode.

   408 

   409 Use RTelSubSessionBase::CancelAsyncRequest(TEMobileCallSwitchAlternatingCall) 

   410 to cancel a previously placed asynchronous SwitchAlternatingCall() request.

   411 

   412 @param aReqStatus On return, KErrNone if the function member was successful, 

   413 or KErrEtelNoClientInterestedInThisCall if there are no valid clients who 

   414 have called the associated NotifyAlternatingCallSwitch(). 

   415 @capability NetworkServices

   416 */

   417 	{

   418 	Blank(EMobileCallSwitchAlternatingCall,aReqStatus);

   419 	}

   420 

   421 EXPORT_C void RMobileCall::NotifyAlternatingCallSwitch(TRequestStatus& aReqStatus) const

   422 /** This notification completes when an alternating call successfully switches 

   423 call mode.

   424 

   425 Use: RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyAlternatingCallSwitch) 

   426 to cancel a previously placed asynchronous NotifyAlternatingCallSwitch() request.

   427 

   428 @param aReqStatus On return, KErrNone is returned after an alternating call 

   429 successfully switched call mode, KErrMMETelAlternatingCallTerminated is returned 

   430 if the TSY detects that the alternating call has ended while a client is still 

   431 waiting for an alternating call mode switch. 

   432 @capability None

   433 */

   434 	{

   435 	Blank(EMobileCallNotifyAlternatingCallSwitch,aReqStatus);

   436 	}

   437 

   438 /***********************************************************************************/

   439 //

   440 // Call control methods for all calls

   441 //

   442 /***********************************************************************************/

   443 

   444 EXPORT_C RMobileCall::TMobileCallCapsV1::TMobileCallCapsV1() : 

   445 	iCallControlCaps(0),

   446 	iCallEventCaps(0)

   447 	/** Default constructor, and is present only to support virtual 

   448 	function table export. */

   449 	{

   450 	iExtensionId = KETelExtMultimodeV1;

   451 	}

   452 

   453 EXPORT_C TInt RMobileCall::GetMobileCallCaps(TDes8& aCaps) const

   454 /** Gets the mobile call's call control and event capabilities.

   455 

   456 @param aCaps On completion, a TMobileCallCapsV1Pckg that will contain the 

   457 call control and event capabilities.

   458 @return KErrNone 

   459 @capability None

   460 

   461 @see TMobileCallCapsV1Pckg

   462 @see TMobileCallCapsV1

   463 */

   464 	{

   465 	return Get(EMobileCallGetMobileCallCaps, aCaps);

   466 	}

   467 

   468 EXPORT_C void RMobileCall::NotifyMobileCallCapsChange(TRequestStatus& aReqStatus, TDes8& aCaps) const

   469 /** This notification completes when the mobile call's call control and event capabilities 

   470 change.

   471 

   472 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange) 

   473 to cancel a previously placed asynchronous NotifyMobileCallCapsChange() request.

   474 

   475 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   476 the system-wide error codes.

   477 @param aCaps On completion, TMobileCallCapsV1Pckg that will contain the new 

   478 call control and event capabilities. 

   479 @capability None

   480 

   481 @see TMobileCallCapsV1Pckg

   482 @see TMobileCallCapsV1

   483 */

   484 	{

   485 	Get(EMobileCallNotifyMobileCallCapsChange, aReqStatus, aCaps);

   486 	}

   487 

   488 EXPORT_C TInt RMobileCall::GetMobileCallStatus(TMobileCallStatus& aStatus) const

   489 /** Gets the current status of a mobile call.

   490 

   491 @param aStatus On completion, contains the status of the call.

   492 @return KErrNone 

   493 @capability None

   494 */

   495 	{

   496 	TPckg<TMobileCallStatus> ptr1(aStatus);

   497 	return Get(EMobileCallGetMobileCallStatus, ptr1);

   498 	}

   499 

   500 EXPORT_C void RMobileCall::NotifyMobileCallStatusChange(TRequestStatus& aReqStatus, TMobileCallStatus& aStatus) const

   501 /** Allows a client to be notified when the call changes state.

   502 

   503 The request completes when the call changes state, the new state being passed 

   504 in the aStatus parameter.

   505 

   506 Use RTelSubSessionBase::CancelAsyncRequest(TEMobileCallNotifyMobileCallStatusChange) 

   507 to cancel a previously placed asynchronous NotifyMobileCallStatusChange() 

   508 request.

   509 

   510 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   511 the system-wide error codes.

   512 @param aStatus On completion, contains the new call state. 

   513 @capability None

   514 */

   515 	{

   516 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   517 

   518 	TPtr8& ptr1=iMmPtrHolder->Set(CMobileCallPtrHolder::ESlot1NotifyMobileCallStatusChange, aStatus);

   519 

   520 	Get(EMobileCallNotifyMobileCallStatusChange, aReqStatus, ptr1);

   521 	}

   522 

   523 EXPORT_C void RMobileCall::Hold(TRequestStatus& aReqStatus) const

   524 /** Puts a call on hold.

   525 

   526 It will complete when the network confirms that the call is in the hold state. 

   527 It can be called by any client that has a handle on this call (i.e. not necessarily 

   528 the client that first opened and dialed or answered the call). The action 

   529 is only valid if the call is a voice call and if there are no other calls 

   530 already on hold. If call hold is possible then it will be reflected in that 

   531 call's dynamic capabilities, i.e. the KCapsHold bit of TMobileCallControlCaps 

   532 will be set.

   533 

   534 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallHold) to cancel a previously 

   535 placed asynchronous Hold() request.

   536 

   537 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   538 the system-wide error codes. 

   539 @capability NetworkServices

   540 */

   541 	{

   542 	Blank(EMobileCallHold,aReqStatus);

   543 	}

   544 

   545 EXPORT_C void RMobileCall::Resume(TRequestStatus& aReqStatus) const

   546 /** Resumes a call that is on hold.

   547 

   548 It will complete when the network confirms that the call is in the active 

   549 state. It can be called by any client that has a handle on this call (i.e. 

   550 not necessarily the client that first opened and dialed or answered the call). 

   551 This action is only valid if there are no other calls already active. If call 

   552 resume is possible then it will be reflected in that call's dynamic capabilities, 

   553 i.e. the KCapsResume bit of TMobileCallControlCaps will be set.

   554 

   555 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallResume) to cancel a 

   556 previously placed asynchronous Resume() request.

   557 

   558 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   559 the system-wide error codes. 

   560 @capability NetworkServices

   561 */

   562 	{

   563 	Blank(EMobileCallResume, aReqStatus);

   564 	}

   565 

   566 EXPORT_C void RMobileCall::Swap(TRequestStatus& aReqStatus) const

   567 /** Swaps a connected call to its opposite state, either active 

   568 or on hold. 

   569 

   570 This function member will complete either when the call has successfully 

   571 moved to the opposite state or if the action failed due to some reason. It 

   572 can be called by any client that has a handle on this call (i.e. not necessarily 

   573 the client that first opened and dialed or answered the call).

   574 

   575 This action is possible under two circumstances:

   576 

   577 There is just one active or held single call. This implies that there are 

   578 no other calls already in the state to which the client wishes to move this 

   579 call to. The client will call Swap on this call and if it is active it will 

   580 move to the held state and if it is held it will move to the active state.

   581 

   582 There are two single calls, one currently active and one on hold. This function 

   583 member therefore swaps the active call with the held call, simultaneously 

   584 placing the active call on hold and resuming the held call.

   585 

   586 In the first circumstance, an active call's dynamic capabilities will contain 

   587 the KCapsHold and KCapsSwap bits set. A held calls' dynamic capabilities will 

   588 contain the KCapsResume and KCapsSwap bits set. In the second circumstance, 

   589 both the active and held call's dynamic capabilities will contain just the 

   590 KCapsSwap bit set. The above function member is applicable to both single 

   591 and conference calls. If there is a single call and a conference call then 

   592 the client can call Swap on either the single call or the conference call. 

   593 The action will still move both the single call and the conference call to 

   594 their opposite states.

   595 

   596 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallSwap) to cancel a previously 

   597 placed asynchronous Swap() request.

   598 

   599 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   600 the system-wide error codes. 

   601 @capability NetworkServices

   602 */

   603 	{

   604 	Blank(EMobileCallSwap, aReqStatus);

   605 	}

   606 

   607 EXPORT_C void RMobileCall::Deflect(TRequestStatus& aReqStatus, TMobileCallDeflect aDeflectType, const RMobilePhone::TMobileAddress& aDestination) const

   608 /** Allows a client to deflect an incoming call that is still 

   609 in the EStatusRinging state.

   610 

   611 The destination of the deflected call is determined by the aDeflectType parameter. 

   612 If this parameter equals EDeflectSuppliedNumber then the destination address 

   613 is given in the aDestination parameter. If call deflection is possible then 

   614 it will be reflected in that call's dynamic capabilities, i.e. the KCapsDeflect 

   615 bit of TMobileCallControlCaps will be set.

   616 

   617 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallDeflect) to cancel a 

   618 previously placed asynchronous Deflect() request.

   619 

   620 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   621 the system-wide error codes.

   622 @param aDeflectType Type of call deflection wanted.

   623 @param aDestination The telephone number (E164) to deflect the call to. 

   624 @capability NetworkServices

   625 */

   626 	{

   627 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   628 

   629 

   630 	iMmPtrHolder->iDeflectType = aDeflectType;

   631 	TPtrC8& ptr1=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot1Deflect, iMmPtrHolder->iDeflectType);

   632 	TPtrC8& ptr2=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot2Deflect, aDestination);

   633 

   634 	Set(EMobileCallDeflect, aReqStatus, ptr1, ptr2);

   635 	}

   636 

   637 EXPORT_C void RMobileCall::Transfer(TRequestStatus& aReqStatus) const

   638 /** Allows a client to transfer a call so that the remote 

   639 party of one call ends up connected to the remote party of another call while 

   640 this user drops out of both calls. For call transfer to be possible, the phone 

   641 must have one call on hold and another call either connected or still ringing 

   642 at the remote end. If call transfer is possible then it will be reflected 

   643 in the affected call's dynamic capabilities, i.e. the KCapsTransfer bit of 

   644 TMobileCallControlCaps will be set.

   645 

   646 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallTransfer) to cancel 

   647 a previously placed asynchronous Transfer() request. 

   648 

   649 @param aReqStatus On return, KErrNone if successful, KErrMMETelWrongMode if 

   650 the transfer is requested for a CDMA call. 

   651 @capability NetworkServices

   652 */

   653 	{

   654 	Blank(EMobileCallTransfer,aReqStatus);

   655 	}

   656 

   657 EXPORT_C void RMobileCall::GoOneToOne(TRequestStatus& aReqStatus) const

   658 /** Requests a private communication to the remote party of 

   659 one call within a conference call. The rest of the conference call will be 

   660 put on hold while the user and the selected remote party go "one-to-one". 

   661 It can be called by any client that has a handle on this call (i.e. not necessarily 

   662 the client that first opened and dialed or answered the call). The action 

   663 is only valid if the MS is in GSM mode, the selected call is a voice call 

   664 and it is a member of an ongoing conference call. If "one-to-one" is possible 

   665 then it will be reflected in that call's dynamic capabilities, i.e. the KCapsOneToOne 

   666 bit of TMobileCallControlCaps will be set.

   667 

   668 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallGoOneToOne) to cancel 

   669 a previously placed asynchronous GoOneToOne() request.

   670 

   671 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   672 the system-wide error codes. 

   673 @capability NetworkServices

   674 */

   675 	{

   676 	Blank(EMobileCallGoOneToOne,aReqStatus);

   677 	}

   678 

   679 EXPORT_C void RMobileCall::NotifyCallEvent(TRequestStatus& aReqStatus, TMobileCallEvent& aEvent) const

   680 /** Allows the client to be notified when various call events occur.

   681 

   682 These events may be generated locally (i.e. from within the ME) or remotely 

   683 (by the remote connected party). The request completes when an event occurs. 

   684 Upon completion, the aEvent parameter will return the event type.

   685 

   686 The call (and line) status will be changed to reflect any events detected 

   687 locally or remotely. 

   688 

   689 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyCallEvent) to 

   690 cancel a previously placed asynchronous NotifyCallEvent() request.

   691 

   692 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   693 the system-wide error codes.

   694 @param aEvent On completion, contains the new call event. 

   695 @capability None

   696 */

   697 	{

   698 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   699 

   700 	TPtr8& ptr1=iMmPtrHolder->Set(CMobileCallPtrHolder::ESlot1NotifyCallEvent, aEvent);

   701 

   702 	Get(EMobileCallNotifyCallEvent, aReqStatus, ptr1);

   703 	}

   704 

   705 EXPORT_C void RMobileCall::DialNoFdnCheck(TRequestStatus& aReqStatus,const TDesC& aTelNumber) const

   706 /**

   707 Dials the number specified by aTelNumber. 

   708 

   709 The number used for dialling is not checked against those in the Fixed 

   710 Dialling Number list even if the FDN service is enabled.

   711 Null CallParams are applied.

   712 

   713 @param aTelNumber Supplies the number to dial.

   714 

   715 @capability NetworkServices

   716 @capability NetworkControl

   717 */

   718 	{

   719 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   720 

   721 	// Confirm that we DO have a number to dial

   722  	if(aTelNumber.Length()==0)

   723  		{

   724  		TRequestStatus* status=&aReqStatus;

   725  		User::RequestComplete(status, KErrArgument);

   726  		return;

   727  		}

   728 

   729 	TPtr8 nullptr(NULL,0);

   730  	TPtrC8& null=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot1DialNoFdnCheck, nullptr);

   731  	Set(EMobileCallDialNoFdnCheck, aReqStatus, null, aTelNumber);

   732 	}

   733 

   734 EXPORT_C void RMobileCall::DialNoFdnCheck(TRequestStatus& aReqStatus,const TDesC8& aCallParams,const TDesC& aTelNumber) const

   735 /**

   736 Dials the number specified by aTelNumber. 

   737 

   738 The number used for dialling is not checked against those in the 

   739 Fixed Dialling Number list even if the FDN service is enabled.

   740 

   741 @param aCallParams Supplies the call parameters.  This should be a packaged RCall::TCallParams derived class.

   742 @param aTelNumber Supplies the number to dial.

   743 

   744 @capability NetworkServices

   745 @capability NetworkControl

   746 

   747 @see TMobileCallParamsV1

   748 @see TMobileCallParamsV2

   749 @see TMobileCallParamsV7

   750 @see TMobileDataCallParamsV1

   751 @see TMobileDataCallParamsV2

   752 @see TMobileDataCallParamsV8

   753 @see TMobileHscsdCallParamsV1

   754 @see TMobileHscsdCallParamsV2

   755 @see TMobileHscsdCallParamsV7

   756 @see TMobileHscsdCallParamsV8

   757 */

   758 	{

   759 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   760 

   761 	// Confirm that we DO have a number to dial

   762  	if(aTelNumber.Length()==0)

   763  		{

   764  		TRequestStatus* status=&aReqStatus;

   765  		User::RequestComplete(status, KErrArgument);

   766  		return;

   767  		}

   768 	

   769  	Set(EMobileCallDialNoFdnCheck, aReqStatus, aCallParams, aTelNumber);

   770 	}

   771 	

   772 EXPORT_C void RMobileCall::DialCallControl(TRequestStatus& aStatus, const TDesC8& aCallParams, const TTelNumberC& aTelNumber) const

   773 /**

   774 Dial the number specified in aTelNumber using the call parameters

   775 specified in aCallParams.  This API differs from the standard

   776 RCall::Dial method to allow the TSY to know that the dial request 

   777 is resulting from Call Control.

   778 

   779 When a client wishes to dial a call (using one of the 

   780 other dial APIs such as RCall::Dial) and Call Control is being 

   781 used, the dial request is passed to the Call Control which can

   782 then modify the call parameters originally specified by the

   783 client.  The SAT engine then issues a second dial request to 

   784 make the actual call using the new modified parameters.  

   785 When making this second request, this API should be used to 

   786 indicate to the TSY that this call results from Call Control.

   787 Call parameter classes RMobileCall::TMobileCallParamsV7 and 

   788 RMobileCall::TMobileHscsdCallParamsV2 (and in future one of their

   789 derived classes) allow the call originator to be specified.

   790 

   791 The API RMobileCall::GetMobileCallInfo with 

   792 RMobileCall::TMobileCallInfoV7 also allows a client to get

   793 information regarding the originator of a call.

   794 

   795 Error codes returned by this API from the TSY/Etelmm via 

   796 aStatus are:

   797 

   798 	- KErrNone if the dial request was successful.

   799 	- KErrArgument if no number was supplied or an invalid telephone number was passed in aTelNumber.

   800 	- KErrPermissionDenied if the client does not have the required PlatSec capabilities or the SID of the SAT engine was not provided (see below for more details). 

   801 	- Another error code depending on the failure.

   802 

   803 This API is policed by both Platform Security capabilities and SID 

   804 and can only be called by the SAT engine.

   805 

   806 On hardware, the API can be called by providing the SID of the SAT 

   807 engine in ETel.iby file found in \epoc32\rom\include

   808 

   809 A patchable constant KSatEngineSid is used for defining the SID value

   810 of the SAT engine.

   811 

   812 For example, add the following line to ETel.iby:

   813 patchdata etel.dll@KSatEngineSid 0x12345678

   814 

   815 On emulator, the API can be called by providing the SID of the SAT

   816 engine in epoc.ini file found at \epoc32\data

   817 

   818 To do this, add the following line to \epoc32\data\epoc.ini

   819 etel_KSatEngineSid <SID>

   820 

   821 For example:

   822 etel_KSatEngineSid 0x12345678

   823 

   824 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallDialCallControl) to 

   825 cancel a previously placed asynchronous DialCallControl() request.

   826 

   827 @param aCallParams The call parameters. This should be a 

   828 packaged RCall::TCallParams derived class. 

   829 

   830 @param aTelNumber The number to dial.

   831 

   832 @param aStatus On completion aReqStatus contains KErrNone if successful. 

   833 Otherwise, another error code depending on failure.

   834 

   835 @see RMobileCall::TMobileCallParamsV7

   836 @see RMobileCall::TMobileDataCallParamsV1

   837 @see RMobileCall::TMobileHscsdCallParamsV7

   838 

   839 @capability NetworkServices

   840 @capability NetworkControl

   841 */

   842 	{

   843 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   844 	

   845 	// Check that a number to dial has been passed

   846  	if(aTelNumber.Length()==0)

   847  		{

   848  		TRequestStatus* status=&aStatus;

   849  		User::RequestComplete(status, KErrArgument);

   850  		return;

   851  		}

   852  	

   853  	Set(EMobileCallDialCallControl, aStatus, aCallParams, aTelNumber); 	

   854 	}

   855 

   856 EXPORT_C RMobileCall::TAudioToneV3::TAudioToneV3() :

   857 	iEvent(EAudioStop),

   858 	iTone(ENoTone),

   859 	iPlayedLocally(EFalse)	

   860 /**

   861 Default constructor.

   862 */

   863 	{

   864 	iExtensionId = KETelExtMultimodeV3;

   865 	}

   866 	

   867 EXPORT_C void RMobileCall::NotifyAudioToneEvent(TRequestStatus& aReqStatus, TDes8& aToneInfo) const

   868 /**

   869 Notification completes when there has been a change of call control audio tone event.   

   870  

   871 @param aReqStatus returns the result code after the asynchronous call completes.

   872 @param aToneInfo Will contain the information on whether the tone is to start/stop playing, 

   873 what tone is playing/to be played and whether the tone is to be played locally by the ME.

   874 This should be a packaged RMobileCall::TAudioToneV3 or derived class.

   875 

   876 @capability None

   877 

   878 @see TAudioToneV3Pckg

   879 */

   880 	{

   881 	Get(EMobileCallNotifyAudioToneEvent, aReqStatus, aToneInfo);	

   882 	}

   883 

   884 /***********************************************************************************/

   885 //

   886 // MobilePrivacy functional unit

   887 //

   888 /***********************************************************************************/

   889 

   890 

   891 EXPORT_C TInt RMobileCall::SetPrivacy(RMobilePhone::TMobilePhonePrivacy aPrivacySetting) const

   892 /** Causes the phone to request a new privacy setting for this call.

   893 

   894 This setting will over-ride (for this call only), the phone's default privacy 

   895 setting.

   896 

   897 The function member is synchronous for two reasons. Firstly because the phone 

   898 may not be able to request the new setting immediately if the call has not 

   899 started yet. Secondly, the CDMA network only sends confirmation of a successful 

   900 privacy setting and will not respond if it is unable to service the request. 

   901 This means a client needs to request a privacy setting but then not assume 

   902 the setting is active until "notify privacy confirmation" completes.

   903 

   904 @leave KErrMMEtelWrongMode if request made during a mode that does not support it

   905 @param aPrivacySetting Wanted privacy setting (either on or off).

   906 @return KErrNone if request processed successfully. KErrMMEtelWrongMode if 

   907 request made during a mode that does not support it. 

   908 @capability NetworkServices

   909 */

   910 	{

   911 	TPckg<RMobilePhone::TMobilePhonePrivacy> ptr1(aPrivacySetting);

   912 	return Set(EMobileCallSetPrivacy, ptr1);	

   913 	}

   914 

   915 EXPORT_C void RMobileCall::NotifyPrivacyConfirmation(TRequestStatus& aReqStatus, RMobilePhone::TMobilePhonePrivacy& aPrivacySetting) const

   916 /** This notification completes when the network confirms whether privacy is on 

   917 or off for this call.

   918 

   919 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyPrivacyConfirmation) 

   920 to cancel a previously placed asynchronous NotifyPrivacyConfirmation() request.

   921 

   922 @param aReqStatus On return, KErrNone if request processed successfully. KErrMMEtelWrongMode 

   923 if request made during a mode that does not support it.

   924 @param aPrivacySetting On completion, the confirmed privacy setting (either 

   925 on or off). 

   926 @capability NetworkServices

   927 */

   928 	{

   929 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   930 

   931 	TPtr8& ptr1 = iMmPtrHolder->Set(CMobileCallPtrHolder::ESlot1NotifyPrivacyConfirmation,aPrivacySetting);

   932 

   933 	Get(EMobileCallNotifyPrivacyConfirmation,aReqStatus,ptr1);

   934 	}

   935 

   936 /***********************************************************************************/

   937 //

   938 // MobileTrafficChannel Functional Unit

   939 //

   940 /***********************************************************************************/

   941 

   942 

   943 

   944 EXPORT_C TInt RMobileCall::SetTrafficChannel(TMobileCallTch aTchRequest) const

   945 /** Sets a new value for the traffic channel setting of a mobile call.

   946 

   947 The function member is synchronous for two reasons. Firstly because the phone 

   948 may not be able to request the new setting immediately if the call has not 

   949 started yet. Secondly, the CDMA network only sends confirmation of a successful 

   950 traffic channel allocation and will not respond if it is unable to service 

   951 the request. This means a client needs to request a traffic channel type but 

   952 then not assume the channel is allocated until "notify traffic channel confirmation" 

   953 completes.

   954 

   955 @leave KErrMMEtelWrongMode if request made during a mode that does not support it

   956 @param aTchRequest The wanted traffic channel (either analog or digital).

   957 @return KErrNone if request processed successfully, KErrMMEtelWrongMode if 

   958 request made during a mode that does not support it. 

   959 @capability NetworkServices

   960 */

   961 	{

   962 	TPckg<TMobileCallTch> ptr1(aTchRequest);

   963 	return Set(EMobileCallSetTrafficChannel,ptr1);

   964 	}

   965 

   966 EXPORT_C void RMobileCall::NotifyTrafficChannelConfirmation(TRequestStatus& aReqStatus, TMobileCallTch& aTchType) const

   967 /** Allows the client to be notified when the CDMA network 

   968 has confirmed the traffic channel type requested during call set-up or during 

   969 call connection.

   970 

   971 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyTrafficChannelConfirmation) 

   972 to cancel a previously placed asynchronous NotifyTrafficChannelConfirmation() 

   973 request. 

   974 

   975 @param aReqStatus On return, KErrNone if successful, otherwise another of 

   976 the system-wide error codes.

   977 @param aTchType On completion, the traffic channel type (either analog or digital). 

   978 @capability NetworkServices

   979 */

   980 	{

   981 	__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

   982 

   983 	TPtr8& ptr1 = iMmPtrHolder->Set(CMobileCallPtrHolder::ESlot1NotifyTrafficChannelConfirmation,aTchType);

   984 

   985 	Get(EMobileCallNotifyTrafficChannelConfirmation,aReqStatus,ptr1);

   986 	}

   987 

   988 /***********************************************************************************/

   989 //

   990 // Call Information methods  for calls of any type

   991 //

   992 /***********************************************************************************/

   993 

   994 EXPORT_C RMobileCall::TMobileCallInfoV1::TMobileCallInfoV1() 

   995 :   iValid(0), 

   996 	iService(RMobilePhone::EServiceUnspecified), 

   997 	iStatus(EStatusUnknown), 

   998 	iCallId(-1), 

   999 	iExitCode(0), 

  1000 	iEmergency(EFalse),

  1001 	iForwarded(EFalse),

  1002 	iPrivacy(RMobilePhone::EPrivacyUnspecified),

  1003 	iAlternatingCall(RMobilePhone::EAlternatingModeUnspecified),

  1004 	iDuration(0),

  1005 	iTch(RMobileCall::ETchUnknown)

  1006 	/** Default constructor, and is present only to support virtual 

  1007 	function table export. */

  1008 	{

  1009 	iExtensionId = KETelExtMultimodeV1;

  1010 	}

  1011 	

  1012 EXPORT_C RMobileCall::TMobileCallInfoV3::TMobileCallInfoV3()

  1013 	: TMobileCallInfoV1(),

  1014 	  iSecurity(RMobilePhone::ECipheringOff)

  1015 /**

  1016 Default constructor.

  1017 */

  1018 	{

  1019 	iExtensionId = KETelExtMultimodeV3;

  1020 	}

  1021 

  1022 EXPORT_C RMobileCall::TMobileCallInfoV7::TMobileCallInfoV7()

  1023 	: 	TMobileCallInfoV3(),

  1024     	iCallParamOrigin(EOriginatorUnknown),

  1025 		iParamsCallControlModified(EFalse)

  1026 /**

  1027 Default constructor.

  1028 */

  1029 	{

  1030 	iExtensionId = KEtelExtMultimodeV7;

  1031 	iIconId.iQualifier = EIconQualifierNotSet;

  1032 	iIconId.iIdentifier = 0;

  1033 	}

  1034 

  1035 EXPORT_C RMobileCall::TMobileCallInfoV8::TMobileCallInfoV8()

  1036 : 	TMobileCallInfoV7(),

  1037     iBCRepeatIndicator(EBCAlternateMode)

  1038 /** Default constructor. The BC Repeat Indicator is initialized to EBCAlternateMode. */

  1039 	{

  1040 	iExtensionId = KEtelExtMultimodeV8;

  1041 	}

  1042 

  1043 EXPORT_C TInt RMobileCall::GetMobileCallInfo(TDes8& aCallInfo) const

  1044 /** Retrieves the current snapshot of all information related 

  1045 to this call as described in the TMobileCallInfoV1 class.

  1046 @leave KErrNotFound if call information is not available

  1047 @param aCallInfo On completion, a TMobileCallInfoV1Pckg holding 

  1048 the call information block.

  1049 @return KErrNone, KErrNotFound if call information is not available 

  1050 @capability ReadUserData

  1051 */

  1052 	{

  1053 	return Get(EMobileCallGetMobileCallInfo, aCallInfo);

  1054 	}

  1055 

  1056 EXPORT_C RMobileCall::TMobileCallRemotePartyInfoV1::TMobileCallRemotePartyInfoV1() 

  1057 	: iRemoteIdStatus(ERemoteIdentityUnknown), iDirection(EDirectionUnknown)

  1058 /** Default constructor, and is present only to support virtual 

  1059 function table export. */

  1060 	{

  1061 	iExtensionId = KETelExtMultimodeV1;

  1062 	}

  1063 

  1064 EXPORT_C void RMobileCall::NotifyRemotePartyInfoChange(TRequestStatus& aReqStatus, TDes8& aRemotePartyInfo) const

  1065 /** Allows the client to be notified of any change in the remote party information.

  1066 

  1067 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange) 

  1068 to cancel a previously placed asynchronous NotifyRemotePartyInfoChange() request.

  1069 

  1070 @param aReqStatus On return, KErrNone if successful, otherwise another of 

  1071 the system-wide error codes.

  1072 @param aRemotePartyInfo On completion, the new remote party information in 

  1073 a TMobileCallRemotePartyInfoV1Pckg. 

  1074 @capability ReadUserData

  1075 */

  1076 	{

  1077 	Get(EMobileCallNotifyRemotePartyInfoChange, aReqStatus, aRemotePartyInfo);

  1078 	}

  1079 

  1080 /***********************************************************************************/

  1081 //

  1082 // MobileCallEmergency functional unit

  1083 // 

  1084 /***********************************************************************************/

  1085 

  1086 EXPORT_C void RMobileCall::DialEmergencyCall(TRequestStatus& aReqStatus, const TDesC& aNumber) const

  1087 /** Places an emergency call request.

  1088 

  1089 It is advised that the client opens a call object during system initialization 

  1090 and reserves it for an emergency call. This will guarantee that it will not 

  1091 leave with a KErrOutOfMemory, which could happen if the client had to open 

  1092 a new call to make the emergency call.

  1093 

  1094 The TSY should make sure that any needed resource for an emergency call is 

  1095 created at initialization and set aside in the event of a DialEmergencyCall() 

  1096 request. Upon receiving a DialEmergencyCall() request, the TSY should ask 

  1097 the ETel server if the client is a priority client, using the following call 

  1098 to the server: CCallBase::CheckPriorityClient().

  1099 

  1100 DialEmergencyCall is designated a "priority client" request, which means that 

  1101 if a client that is known to the server as a priority client calls this, the 

  1102 server will guarantee that it will not leave with KErrOutOfMemory. However, 

  1103 a non-priority client may call it without this guarantee.

  1104 

  1105 This function member is similar to the standard Dial() function member in 

  1106 that it will initiate a call set-up. The emergency call object will follow 

  1107 the standard call states.

  1108 

  1109 Use RTelSubSessionBase::CancelAsyncRequest(EMobileCallDialEmergencyCall) to 

  1110 cancel a previously placed asynchronous DialEmergencyCall() request.

  1111 

  1112 @param aReqStatus On return, KErrNone if the emergency call successfully reaches 

  1113 the connected state. If the call set-up fails, the function member will complete 

  1114 with whatever error was returned by the network.

  1115 @param aNumber The actual emergency number, which is needed to set up an emergency 

  1116 call to a particular emergency centre (e.g. Ambulance, Police, Fire Brigade, 

  1117 etc.). The aNumber parameter should be a RMobileENStore::TEmergencyNumber 

  1118 buffer. 

  1119 @capability NetworkServices

  1120 @capability NetworkControl

  1121 */

  1122 	{

  1123 	TReqPriorityType type=EIsaEmergencyRequest;

  1124 	Set(EMobileCallDialEmergencyCall, aReqStatus, aNumber, type);

  1125 	}

  1126 

  1127 /***********************************************************************************/

  1128 //

  1129 // MobileCallCompletion functional unit

  1130 // 

  1131 /***********************************************************************************/

  1132 

  1133 

  1134 EXPORT_C void RMobileCall::ActivateCCBS(TRequestStatus& aReqStatus, TInt& aIndex) const

  1135 /**