/*
* Copyright (c) 2000-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/


/**
@file

Multimode ETel API header file.

Describes the MM ETel API - classes, methods and types.

@publishedPartner
@released
*/

#ifndef __ETELMM_H__
#define __ETELMM_H__

#include <e32base.h>
#include <s32mem.h>
#include <etel.h>
#include <etelmmcs.h>


/** 
Internal API/TSY delimiter used to pass the phonebook type
*/
#define PHBOOK_DELIMITER		_L("//")
/** The size of the phone book delimiter string.
@internalComponent
 */
const TInt KSizeOfPhbookDelimiter=2;

/**
Names for Multimode ETel sub-sessions
*/
_LIT(KETelMeAdnPhoneBook,"S1");
_LIT(KETelMeDialledPhoneBook,"S2");
_LIT(KETelMeMissedPhoneBook,"S3");
_LIT(KETelMeReceivedPhoneBook,"S4");
_LIT(KETelCombinedAdnPhoneBook,"S5");
_LIT(KETelTaAdnPhoneBook,"S6");
_LIT(KETelIccAdnPhoneBook,"S7");
_LIT(KETelIccFdnPhoneBook,"S8");
_LIT(KETelIccSdnPhoneBook,"S9");
_LIT(KETelIccBdnPhoneBook,"S10");
_LIT(KETelIccLndPhoneBook,"S11");
_LIT(KETelIccVoiceMailBox,"S12");

_LIT(KETelMeSmsStore,"S13");
_LIT(KETelIccSmsStore,"S14");
_LIT(KETelCombinedSmsStore,"S15");

_LIT(KETelNamStore,"S16");
_LIT(KETelOwnNumberStore,"S17");
_LIT(KETelEmergencyNumberStore,"S18");

_LIT(KETelSmsMessaging,"S19");
_LIT(KETelBroadcastMessaging,"S20");
_LIT(KETelUssdMessaging,"S21");

_LIT(KETelConferenceCall,"S22");

_LIT(KETelIccMbdnPhoneBook, "S23");
_LIT(KETelIccMsisdnPhoneBook, "S24");
_LIT(KETelIccOciPhoneBook, "S25");
_LIT(KETelIccIciPhoneBook, "S26");
_LIT(KETelIccNamStore ,"S27");
_LIT(KETelIccInfoPhoneBook, "S28");

_LIT(KETelLocationServices,"S29");

// Types for Multimode ETel sub-sessions

_LIT(KEtelCdmaPhoneBookType,"T1");
_LIT(KEtelGsmPhoneBookType,"T2");
_LIT(KEtelUSimPhoneBookType,"T3");

// Types for SmartCardEap sub-sessions

/**
The prefix to all RMobileSmartCardEap sub-session names.
*/
_LIT(KETelSmartCardEapSession, "ScEap");
/**
The length of KETelSmartCardEapSession.  Used to obtain a const value
for this length at compile-time.
*/
#define SCEAP_SSN_LENGTH 5

/**
EAP-MD5 type identifier.  Value taken from section 5 of RFC 3748 Jun 2004.
This should be used as the EAP type identifier value of
RMobileSmartCardEap::Open() if standard EAP-MD5 challenges are to be used.

This value corresponds to one of the possible values returned in the type
list of TUiccApplicationEapInfoV6.

(Decimal value = 4)

@see RMobileSmartCardEap::Open()
@see RMobilePhone::TUiccApplicationEapInfoV6
*/
_LIT8(KETelSmartCardEapTypeMD5, "04");

/**
EAP-TLS type identifier.  Value taken from section 4.1 of RFC 2716 Oct 1999.
This should be used as the EAP type identifier value of
RMobileSmartCardEap::Open() if standard EAP-TLS is to be used.

This value corresponds to one of the possible values returned in the type
list of TUiccApplicationEapInfoV6.

(Decimal value = 13)

@see RMobileSmartCardEap::Open()
@see RMobilePhone::TUiccApplicationEapInfoV6
*/
_LIT8(KETelSmartCardEapTypeTLS, "0D");

/**
EAP-SIM type identifier.
This should be used as the EAP type identifier value of
RMobileSmartCardEap::Open() if standard EAP-SIM is to be used.

This value corresponds to one of the possible values returned in the type
list of TUiccApplicationEapInfoV6.

(Decimal value = 18)

@see RMobileSmartCardEap::Open()
@see RMobilePhone::TUiccApplicationEapInfoV6
*/
_LIT8(KETelSmartCardEapTypeSIM, "12");

/**
EAP-AKA type identifier.
This should be used as the EAP type identifier value of
RMobileSmartCardEap::Open() if standard EAP-AKA is to be used.

This value corresponds to one of the possible values returned in the type
list of TUiccApplicationEapInfoV6.

(Decimal value = 23)

@see RMobileSmartCardEap::Open()
@see RMobilePhone::TUiccApplicationEapInfoV6
*/
_LIT8(KETelSmartCardEapTypeAKA, "17");

/**
EAP-TTLS type identifier.
This should be used as the EAP type identifier value of
RMobileSmartCardEap::Open() if standard EAP-TTLS is to be used.

This value corresponds to one of the possible values returned in the type
list of TUiccApplicationEapInfoV6.

(Decimal value = 21)

@see RMobileSmartCardEap::Open()
@see RMobilePhone::TUiccApplicationEapInfoV6
*/
_LIT8(KETelSmartCardEapTypeTTLS, "15");

/***********************************************************************************/
//
//  Global Multimode constants and types
// 
/***********************************************************************************/

/**
Unique API identifier and Functional Unit constants
Modes: Common 
*/
enum TMultimodeETelV1Api
	{
	/** TSY supports the Multimode ETel v1.0 API.
	
	Modes: Common */
	KETelExtMultimodeV1=3000,  // 3000 is unique reference for Multimode Etel v1.0 API
	/** TSY supports the MobileSimAccess functional unit.
	
	Modes: Common */
	KETelFuncMobileIccAccess,
	/** TSY supports the MobileNetwork functional unit.
	
	Modes: Common */
	KETelFuncMobileNetwork,
	/** TSY supports the MobileIdentity functional unit.
	
	Modes: Common */
	KETelFuncMobileIdentity,
	/** TSY supports the MobilePower functional unit.
	
	Modes: Common */
	KETelFuncMobilePower,
	/** TSY supports the MobileSignal functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileSignal,
	/** TSY supports the MobileIndicator functional unit.
	
	Modes: Common */
	KETelFuncMobileIndicator,
	/** TSY supports the MobileDTMF functional unit.
	
	Modes: Common */
	KETelFuncMobileDTMF,
	/** TSY supports the MobileUserNetworkAccess functional unit.
	
	Modes: Common */
	KETelFuncMobileUserNetworkAccess,
	/** TSY supports the MobileIdentityService functional unit.
	
	Modes: Common */
	KETelFuncMobileIdentityService,
	/** TSY supports the MobileCallForwarding functional unit.
	
	Modes: Common */
	KETelFuncMobileCallForwarding,
	/** TSY supports the MobileCallBarring functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileCallBarring,
	/** TSY supports the MobileCallWaiting functional unit.
	
	Modes: Common */
	KETelFuncMobileCallWaiting,
	/** TSY supports the MobileCallCompletion functional unit. */
	KETelFuncMobileCallCompletion,
	/** TSY supports the MobileAlternatingCall functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileAlternatingCall,
	/** TSY supports the MobileCost functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileCost,
	/** TSY supports the MobileSecurity functional unit.
	
	Modes: Common */
	KETelFuncMobileSecurity,
	/** TSY supports the MobileAlternateLineService functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileAlternateLineService,
	/** TSY supports the MobileMessageWaiting functional unit.
	
	Modes: Common */
	KETelFuncMobileMessageWaiting,
	/** TSY supports the MobileFixedDiallingNumbers functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileFixedDiallingNumbers,
	/** TSY supports the MobileDataCall functional unit.
	
	Modes: Common */
	KETelFuncMobileDataCall,
	/** TSY supports the MobilePrivacy functional unit.
	
	Modes: CDMA */
	KETelFuncMobilePrivacy,
	/** TSY supports the MobileEmergencyCall functional unit.
	
	Modes: Common */
	KETelFuncMobileEmergencyCall,
	/** TSY supports the MobileSmsMessaging functional unit.
	
	Modes: Common */
	KETelFuncMobileSmsMessaging,
	/** TSY supports the MobileBroadcastMessaging functional unit.
	
	Modes: Common */
	KETelFuncMobileBroadcastMessaging,
	/** TSY supports the MobileUssdMessaging functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileUssdMessaging,
	/** TSY supports the MobileConferenceCall functional unit.
	
	Modes: Common */
	KETelFuncMobileConferenceCall,
	/** TSY supports the MobilePhonebookStore functional unit.
	
	Modes: Common */
	KETelFuncMobilePhonebook,
	/** TSY supports the MobileSmsStore functional unit.
	
	Modes: Common */
	KETelFuncMobileSmsStore,
	/** TSY supports the MobileNamStore functional unit.
	
	Modes: CDMA */
	KETelFuncMobileNamStore,
	/** TSY supports the MobileONStore functional unit.
	
	Modes: Common */
	KETelFuncMobileOwnNumberStore,
	/** TSY supports the MobileENStore functional unit.
	
	Modes: Common */
	KETelFuncMobileEmergencyNumberStore,
	/** TSY supports the MobileMultimedia functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileMulticall,
	/** TSY supports the MobileNextIncomingCall functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileNextIncomingCall,
	/** TSY supports the MobileMultimediaCall functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileMultimediaCall,
	/** TSY supports the MobileUserSignalling functional unit.
	
	Modes: GSM/WCDMA */
	KETelFuncMobileUserSignalling
	};

/** Unique API identifier and Functional Unit constants.
Modes: WCDMA 

*/
enum TMultimodeETelV2Api
	{
	/** TSY supports the Multimode ETel v2.0 API.
	
	Modes: WCDMA */
	KETelExtMultimodeV2=7000,  // 7000 is unique reference for Multimode Etel v2.0 API
	/** TSY supports the MobileMultimediaCallSettings functional unit.
	
	Modes: WCDMA */
	KEtelFuncMobileMultimediaCallSettings,
	/** TSY supports the MobileNetworkSecurity functional unit.
	
	Modes: WCDMA */
	KEtelFuncMobileNetworkSecurity,
	KEtelFuncMobileUSIMApplications
	};
	
/**
Enum to define the v3.0 API additions

*/
enum TMultimodeETelV3Api
	{
	/**
	Indicator that the TSY supports the Multimode ETel v3.0 API.
	*/
	KETelExtMultimodeV3 = 10000,	
	/**
	TSY supports the MobileMMSInformation functional unit.
	*/
	KEtelFuncMobileMMSInformation,       // 10001
	/**
	TSY supports the KEtelFuncMobileAirTime functional unit.
	*/
	KEtelFuncMobileAirTime,              // 10002
	/**
	TSY supports the KEtelFuncMobileAutoRedial functional unit.
	*/
	KEtelFuncMobileAutoRedial,           // 10003
	/**
	TSY supports the KEtelFuncMobilePersonalisation functional unit.
	*/
	KEtelFuncMobilePersonalisation,      // 10004
	/**
	TSY supports the KEtelMobileMailboxNumbers functional unit.
	*/
	KEtelFuncMobileMailboxNumbers,       // 10005
	/**
	TSY supports the Mobile APN Control List functional unit.
	*/
	KEtelFuncMobileAPNControlList        // 10006
	};

/**
Enum to define the v4.0 API additions

*/
enum TMultimodeETelV4Api
	{
	/**
	Indicator that the TSY supports the Multimode ETel v4.0 API.
	*/
	KETelExtMultimodeV4	= 15000
	};


/** Enum to define Release 5 enabling API and data structures
*/
enum TMultimodeEtelV5Api
	{
	/**
	Indicator that the TSY supports the Multimode ETel v5.0 API.
	*/	
	KEtelExtMultimodeV5=20000,
	/**
	Indicator that the TSY supports the IMS functional unit.
	*/	
	KEtelFuncMobileIMS,                  // 20001
	/**
	TSY supports the KEtelFuncMobileSmartCardApplications functional unit.
	*/
	KEtelFuncMobileSmartCardApplications // 20002
	};


/**
Enum to define the v6.0 API additions.
*/
enum TMultimodeEtelV6Api
	{
	/**
	Indicator that the TSY supports the Multimode ETel v6.0 API.
	*/	
	KEtelExtMultimodeV6=25000,
	/**
	Indicator that the TSY supports the EAP supporting functional unit.
	*/	
	KEtelSmartCardEap                    // 25001
	};
/**
Enum to define the v7.0 API additions.
*/
enum TMultimodeEtelV7Api
	{
	/**
	Indicator that the TSY supports the Multimode ETel v7.0 API.
	*/	
	KEtelExtMultimodeV7=30000,
	/**
	Indicator that the TSY supports the LocationServices supporting functional unit.
	*/	
	KEtelLocationControlServices                    // 30001
	};		
/**
Enum to define the Etel 3rdParty V1 API additions

*/
enum TMultimodeETel3rdPartyV1Api 
	{
	/**
	Indicator that the TSY supports the Etel 3rd Party v1.0 API
	*/
	KETelExt3rdPartyV1 = 40000
	};

/*********************************************************/
//
// Phone based functionality (RMobilePhone)
// 
/*********************************************************/


class CMobilePhonePtrHolder;
class CMobilePhoneStoredNetworkList;
class RMobileSmartCardEap;

class RMobilePhone : public RPhone
/**
Provides client access to mobile phone functionality provided by TSY.

Encapsulates access to a mobile phone. The functionality of RMobilePhone 
is divided into a number of functional units, for the purpose of easier documentation 
and navigation and selectable support by TSY.

Note: Some RMobilePhone function members must be supported by the TSY while 
others are part of optional "functional unit" and only need to be supported 
if the TSY supports that functional unit. When a functional unit is mandatory 
then the unit should at least support the Get...Caps() member function to 
indicate the member functions that are supported for this unit.
 
*/
	{
public:
	friend class CAsyncRetrievePhoneList;
	IMPORT_C RMobilePhone();

	// Global multimode types

	
	class TMultimodeType
	/**
	Base class for all the V1 parameter types defined within the API.
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TInt ExtensionId() const;
	protected:
		TMultimodeType();
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	protected:
		TInt iExtensionId;
		};
		
	/** A typedef'd packaged TMultimodeType for passing through a generic API 
	function member. */
	typedef TPckg<TMultimodeType> TMultimodeTypePckg;

	// Types used in RMobilePhone::TMobileAddress

/** Address types.

Modes: Common */
	enum TMobileTON
		{
	/** User or the network has no knowledge of the type of number.
	
	Modes: Common */
		EUnknownNumber,			// 0
	/** International number.
	
	Modes: Common */
		EInternationalNumber,	// 1
	/** National number.
	
	Modes: Common */
		ENationalNumber,		// 2
	/** Administration/service number specific to the serving network, e.g. used to 
	access an operator.
	
	Modes: Common */
		ENetworkSpecificNumber, // 3
	/** Subscriber number.
	
	Modes: Common */
		ESubscriberNumber,		// 4 - Also defined as "dedicated, short code" in GSM 04.08
	/** Alphanumeric number coded according to 3GPP TS 123 038 GSM 7-bit default alphabet.
	
	Modes: GSM/WCDMA */
		EAlphanumericNumber,	// 5
	/** Abbreviated number.
	
	Modes: Common */
		EAbbreviatedNumber		// 6
		};

/** Number Plan Indicator.

Modes: Common */
	enum TMobileNPI
		{
	/** User or the network has no knowledge of the numbering plan.
	
	Modes: Common */
		EUnknownNumberingPlan =0,
	/** ISDN/telephony numbering plan.
	
	Modes: Common */
		EIsdnNumberPlan=1,		
	/** Data numbering plan.

	Modes: Common */
		EDataNumberPlan=3,		
	/** Telex numbering plan.

	Modes: Common */
		ETelexNumberPlan=4,	
	/** Service centre specific plan used to indicate a numbering plan specific to external 
	Short Message entities attached to the SMSC. */
		EServiceCentreSpecificPlan1=5,
	/** Service centre specific plan used to indicate a numbering plan specific to external 
	Short Message entities attached to the SMSC.
	
	Modes: GSM/WCDMA */
		EServiceCentreSpecificPlan2=6,
	/** National numbering plan.
	
	Modes: GSM/WCDMA */
		ENationalNumberPlan=8,
	/** Private numbering plan.
	
	Modes: Common */
		EPrivateNumberPlan=9,
	/** ERMES numbering plan.
	
	Modes: GSM/WCDMA */
		EERMESNumberPlan=10
		};

	enum 
		{
		KMaxMobilePasswordSize=10,
		KMaxMobileNameSize=32,
		KMaxMobileTelNumberSize=100
		};

	struct TMMTableSettings
		{
		TUint32 iLocId;
		};

	typedef TPckg<TMMTableSettings> TMMTableSettingsPckg;

	

	class TMobileAddress
	/**
	Defines API abstraction of a mobile telephone number.
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileAddress();
			
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
			
	public:
		/** Type of number.
		
		@see TMobileTON */
		TMobileTON iTypeOfNumber;
		/** Number plan.
		
		@see TMobileNPI */
		TMobileNPI iNumberPlan;
		/** Telephone number. */
		TBuf<KMaxMobileTelNumberSize> iTelNumber;
		};

	// Mobile information location type

	/** Defines Location of service information.

	Modes: Common */
	enum TMobileInfoLocation
		{
		/** Retrieve the service information ONLY from the cache on the phone. Return KErrNotFound 
		if the cache does not exist or it is empty. */
		EInfoLocationCache,
		/** Retrieve the service information from the cache, but if this is empty or does 
		not exist then interrogate the network. */
		EInfoLocationCachePreferred,
		/** Retrieve the service information from the network (and refresh the cache if 
		there is one). */
		EInfoLocationNetwork
		};

	// Mobile call service type

	/** Applicability of request to a mobile service group.

	Modes: Common */
	enum TMobileService
		{
		/** The call service has not been specified.
		
		Modes: Common */
		EServiceUnspecified,
		/** The API request applies to voice call services.

		Modes: Common */
		EVoiceService,
		/** The API request applies to auxiliary voice call services.

		Modes: GSM/WCDMA */
		EAuxVoiceService,
		/** The API request applies to circuit switched data call services.
		
		Modes: Common */
		ECircuitDataService,
		/** The API request applies to packet data services.
	
		Modes: Common */
		EPacketDataService,
		/** The API request applies to fax call services.
	
		Modes: Common */
		EFaxService,
		/** The API request applies to short message services.
	
		Modes: Common */
		EShortMessageService,
		/** The API request applies to all mobile services.
	
		Modes: Common */
		EAllServices,
		/** All teleservices
	
		Modes: Common */
		EAllTele,
		/** Telephony
	
		Modes: Common */
		ETelephony,
		/** All data teleservices
	
		Modes: Common */
		EAllDataTele,
		/** Voice Broadcast Service (VBS) Bearer Service
	
		Modes: Common */
		EAllDataExSms,
		/** All teleservices except SMS
	
		Modes: Common */
		EAllTeleExcSms,
		/** All PLMN specific teleservices
	
		Modes: Common */
		EAllPlmnTele,
		/** PLMN specific teleservice 1
	
		Modes: Common */
		EPlmnTele1,
		/** PLMN specific teleservice 2
	
		Modes: Common */
		EPlmnTele2,
		/** PLMN specific teleservice 3
	
		Modes: Common */
		EPlmnTele3,
		/** PLMN specific teleservice 4
	
		Modes: Common */
		EPlmnTele4,
		/** PLMN specific teleservice 5

		Modes: Common */
		EPlmnTele5,
		/** PLMN specific teleservice 6

		Modes: Common */
		EPlmnTele6,
		/** PLMN specific teleservice 7
	
		Modes: Common */
		EPlmnTele7,
		/** PLMN specific teleservice 8
	
		Modes: Common */
		EPlmnTele8,
		/** PLMN specific teleservice 9
	
		Modes: Common */
		EPlmnTele9,
		/** PLMN specific teleservice 10
	
		Modes: Common */
		EPlmnTeleA,
		/** PLMN specific teleservice 11
	
		Modes: Common */
		EPlmnTeleB,
		/** PLMN specific teleservice 12
	
		Modes: Common */
		EPlmnTeleC,
		/** PLMN specific teleservice 13
	
		Modes: Common */
		EPlmnTeleD,
		/** PLMN specific teleservice 14
	
		Modes: Common */
		EPlmnTeleE,
		/** PLMN specific teleservice 15
	
		Modes: Common */
		EPlmnTeleF,
		/** All bearer services
		
		Modes: Common */
		EAllBearer,
		/** All async services
	
		Modes: Common */
		EAllAsync,
		/** All sync services
	
		Modes: Common */
		EAllSync,
		/** All data circuit sync
	
		Modes: Common */
		ESyncData,
		/** All data circuit async
	
		Modes: Common */
		EAsyncData,
		/** All packet data services
	
		Modes: Common */
		EPacketData,
		/** All pad access services

		Modes: Common */
		EPadAccess,
		/** All PLMN specific bearer services

		Modes: Common */
		EAllPlmnBearer,
		/** PLMN specific bearer service 1
	
		Modes: Common */
		EPlmnBearerServ1,
		/** PLMN specific bearer service 2
	
		Modes: Common */
		EPlmnBearerServ2,
		/** PLMN specific bearer service 3
	
		Modes: Common */
		EPlmnBearerServ3,
		/** PLMN specific bearer service 4
	
		Modes: Common */
		EPlmnBearerServ4,
		/** PLMN specific bearer service 5
	
		Modes: Common */
		EPlmnBearerServ5,
		/** PLMN specific bearer service 6
	
		Modes: Common */
		EPlmnBearerServ6,
		/** PLMN specific bearer service 7
	
		Modes: Common */
		EPlmnBearerServ7,
		/** PLMN specific bearer service 8
	
		Modes: Common */
		EPlmnBearerServ8,
		/** PLMN specific bearer service 9
	
		Modes: Common */
		EPlmnBearerServ9,
		/** PLMN specific bearer service 10
	
		Modes: Common */
		EPlmnBearerServA,
		/** PLMN specific bearer service 11
	
		Modes: Common */
		EPlmnBearerServB,
		/** PLMN specific bearer service 12
	
		Modes: Common */
		EPlmnBearerServC,
		/** PLMN specific bearer service 13
	
		Modes: Common */
		EPlmnBearerServD,
		/** PLMN specific bearer service 14
	
		Modes: Common */
		EPlmnBearerServE,
		/** PLMN specific bearer service 15
	
		Modes: Common */
		EPlmnBearerServF,
		/** Alternative tele services

		Modes: Common */
		EAltTele,
		EVoiceGroupCall,
		EVoiceBroadcast,
		EAllGprsBearer
		};

	// Mobile name type

	/** A typedef to hold the names of API sub-sessions. The names are coded as ASCII 
	characters. */
	typedef TBuf<KMaxMobileNameSize> TMobileName;

	// Mobile password type

	/** A typedef for the standard password used by mobile phones for secure access 
	to services (phone lock, SIM lock, call barring password). The password is 
	coded as Unicode characters. */
	typedef TBuf<KMaxMobilePasswordSize> TMobilePassword;

	// for use by client-side API code and TSY only

	struct TClientId
	/** This type is used within the 2-phase list retrieval classes. During both phases, 
	the client-side API code will pass down the TClientId so that TSY can use
	this information to match the first phase of the request to the second phase. */
		{
		/** The handle to the underlying RTelServer session. */
		TInt iSessionHandle;
		/** The handle to the sub-session to which this API request relates. */
		TInt iSubSessionHandle;
		};

	/** Phone air interface capabilities. */
	enum TMobilePhoneModeCaps
		{
		/** Phone can operate in GSM mode on 900/1800/1900 MHz bands. */
		KCapsGsmSupported=0x00000001,
		/** Phone can operate in GPRS mode on 900/1800/1900 MHz bands. */
		KCapsGprsSupported=0x00000002,
		/** Phone can operate in AMPS mode on 800MHz band. */
		KCapsAmpsSupported=0x00000004,
		/** Phone can operate in CDMA (IS-95) mode on 800/1900 MHz bands. */
		KCapsCdma95Supported=0x00000008,
		/** Phone can operate in CDMA (cdma2000) mode on 800/1900 MHz bands. */
		KCapsCdma2000Supported=0x00000010,
		/** Phone can operate in W-CDMA (UTRA Frequency Division Duplex (FDD)) mode. */
		KCapsWcdmaSupported=0x00000020,
		/** Phone can operate in TDMA/CDMA (UTRA Time Division Duplex (TDD)) mode. */
		KCapsTdcdmaSupported=0x00000040,
		/** 
		Phone can access Smart Card functionality required for an EAP. 
		@deprecated 9.3
		*/
		KCapsEapSupported=0x00000080
		};

	/** Version number of the multimode ETel API. */
	 enum TMultimodeEtelAPIVersion
		{
		/** Multimode Etel API version 1. */
		 TMultimodeETelApiV1
		};

	 //
	 //  API/TSY internal type
	 //
	
	 struct TPhoneStoreNameAndIccType
	/** Structure that holds the phone store name and ICC type.

	Mode: Common */
		{
		/** This parameter is used to set the name of the storage. */
		TName iStoreName;
		/** This parameter is used to set the type of the ICC card. */
		TName iMode;
		};

	IMPORT_C TInt GetMultimodeAPIVersion(TInt& aVersion) const;

	IMPORT_C TInt GetMultimodeCaps(TUint32& aCaps) const;

	IMPORT_C void GetPhoneStoreInfo(TRequestStatus& aReqStatus, TDes8& aInfo, const TDesC& aStoreName) const;

	IMPORT_C void GetPhoneStoreInfo(TRequestStatus& aStatus, TDes8& aInfo, const TDesC& aStoreName, const TDesC& aMode) const;

	// explicit phone initialisation
	IMPORT_C void InitialiseMM(TRequestStatus& aReqStatus, TDes8& aTableSettings) const; 

	/***********************************************************************************/
	//
	// MobilePhoneIccAccess functional unit
	//
	/***********************************************************************************/
	
/** ICC access capabilities.

Modes: GSM */
	enum TMobilePhoneIccCaps
		{
	/** Phone has a SIM and it currently supports SIM access by clients.
	
	Modes: GSM */
		KCapsSimAccessSupported=0x00000001,
	/** Phone has a R-UIM and it currently supports R-UIM access by clients.
	
	Modes: CDMA */
		KCapsRUimAccessSupported=0x00000002,
	/** Phone has a USIM and it currently supports USIM access by clients.
	
	Modes: WCDMA */
		KCapsUSimAccessSupported=0x00000004
		};
		

	enum 
	{
	/**
	Maximum size of an ICC identity. 
	
	NOTE: TS102.221 defines the maximum size of the ICC Identity as held in EF_ICCID as 10 bytes, however
	TS 51.011 mentions that network operators may issue a SIM with an identification number of 20 bytes.  
	Therefore to cover this possibility the higher figure of 20 bytes has been chosen as the maximum size of the ICC identity.
	*/
	KMaxSizeIccIdentity	= 20
	};
	
	/** A typedef to hold the ICC identity.*/
	typedef TBuf8<KMaxSizeIccIdentity> TIccIdentity; 

	IMPORT_C TInt GetIccAccessCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyIccAccessCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;
	IMPORT_C void GetIccIdentity(TRequestStatus& aReqStatus, TIccIdentity& aIdentity) const;

/** The Call Transfer/Call Forward options that are supported by the CSP.

Modes: WCDMA/GSM */
	enum TCspCallOffering
		{
	/** Indicates that "Call Transfer" is supported by the CSP. */
		KCspCT=0x08,
	/** Indicates that "Call Forwarding on Not Reachable" is supported by the CSP. */
		KCspCFNRc=0x10,
	/** Indicates that "Call Forwarding on No Reply" is supported by the CSP. */
		KCspCFNRy=0x20,
	/** Indicates that "Call Forwarding on Busy" is supported by the CSP. */
		KCspCFB=0x40,
	/** Indicates that "Call Forwarding Unconditional" is supported by the CSP. */
		KCspCFU=0x80
		};

/** The call restrictions supported by the CSP.

Modes: GSM/WCDMA */
	enum TCspCallRestriction
		{
	/** Indicates that "Barring of Incoming Calls when roaming outside the home PLMN 
	country" is supported by CSP. */
		KCspBICRoam=0x08,
	/** Indicates that "Barring of All Incoming Calls" is supported by CSP. */
		KCspBAIC=0x10,
	/** Indicates that "Barring of Outgoing International Calls except those directed 
	to the home PLMN country" is supported by CSP. */
		KCspBOICexHC=0x20,
	/** Indicates that "Barring of Outgoing International Calls" is supported by CSP. */
		KCspBOIC=0x40,
	/** Indicates that "Barring of All Outgoing Calls" is supported by CSP. */
		KCspBOAC=0x80
		};

/** Other services supported by the CSP.

Modes: GSM/WCDMA */
	enum TCspOtherSuppServices
		{
	/** Indicates that the Outgoing Access option of the Closed User Group service is 
	supported by the CSP. */
		KCspCUGOA=0x08,
	/** Indicates that the Preferential CUG option of the Closed User Group service 
	is supported by the CSP. */
		KCspPrefCUG=0x10,
	/** Indicates that the Advice of Charge service is supported by the CSP. */
		KCspAoC=0x20,
	/** Indicates that the Closed User Group service is supported by the CSP. */
		KCspCUG=0x40,
	/** Indicates that the Multiparty call service is supported by the CSP */
		KCspMPTY=0x80,
		};

/** Call completion modes supported by this CSP.

Modes: GSM/WCDMA */
	enum TCspCallCompletion
		{
	/** Indicates that the Call Completion to Busy Subscriber service is supported by 
	the CSP. */
		KCspCCBS=0x20,
	/** Indicates that the Call Waiting service is supported by the CSP. */
		KCspCW=0x40,
	/** Indicates that the Call Hold service is supported by the CSP. */
		KCspHOLD=0x80,
		};

/** SMS Teleservices supported by the CSP.

Modes: GSM/WCDMA */
	enum TCspTeleservices
		{
	/** Indicates that display of Validity Period menu options for SMS is supported 
	by the CSP. */
		KCspValidityPeriod=0x02,
	/** Indicates that display of Protocol ID menu options for SMS is supported by the 
	CSP. */
		KCspProtocolID=0x04,
	/** Indicates that SMS Delivery Confirmation is supported by the CSP. */
		KCspDelConf=0x08,
	/** Indicates that display of Reply Path menu options for outgoing SMS is supported 
	by the CSP. */
		KCspReplyPath=0x10,
	/** Indicates that the Cell Broadcast service is supported by the CSP. */
		KCspSMCB=0x20,
	/** Indicates mobile originated Short Messages are supported by CSP. */
		KCspSMMO=0x40,
	/** Indicates mobile terminated Short Messages are supported by CSP. */
		KCspSMMT=0x80,
		};

/** Alternate Line Services */
	enum TCspCPHSTeleservices
		{
	/** Indicates that Alternate Line Service is supported by the CSP. */
		KCspALS=0x80
		};

/** Currently not used. */
	enum TCspCPHSFeatures
		{
	/** This bit value is reserved for SST in Phase 1 CPHS. */
		KCspReservedSST=0x80
		};

/** Number Identification option supported by the CSP.

Modes: GSM/WCDMA */
	enum TCspNumberIdentification
		{
	/** Indicates that Calling Line Identity Presentation blocking per call (CLI sent 
	by default) is supported by the CSP. */
		KCspCLIBlock=0x01,
	/** Indicates that Calling Line Identity Presentation per call (CLI blocked by default) 
	is supported by the CSP. */
		KCspCLISend=0x02,
	/** Indicates that Connected Line Identification Presentation is supported by the 
	CSP. */
		KCspCOLP=0x10,
	/** Indicates that Connected Line Identification Restriction is supported by the 
	CSP. */
		KCspCOLR=0x20,
	/** Indicates that Calling Line Identification Presentation is supported by the CSP. */
		KCspCLIP=0x80,
		};

/** Phase 2+ services supported by the CSP.

Modes: GSM/WCDMA */
	enum TCspPhase2PlusServices
		{
	/** Indicates that Multiple Band roaming is supported by CSP. */
		KCspMultipleband=0x04,
	/** Indicates that Multiple Subscriber Profile is supported by CSP.
	
	v1.0 of Multimode ETel API does not support this feature */
		KCspMSP=0x08,
	/** Indicates that Voice Broadcast is supported by CSP.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KCspVoiceBroadcast=0x10,
	/** Indicates that Voice Group Call is supported by CSP. 
	
	v1.0 of Multimode ETel API does not support this feature. */
		KCspVoiceGroupCall=0x20,
	/** Indicates that High Speed Circuit Switched Data is supported by CSP. */
		KCspHscsd=0x40,
	/** Indicates that General Packet Radio Service is supported by CSP. */
		KCspGprs=0x80
		};

/** Value added services supported by this CSP.

Modes: GSM/WCDMA */
	enum TCspValueAdded
		{
	/** Indicates that display of language selection menus is supported by the CSP.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KCspLanguage=0x01,
	/** Indicates that display of data call option menu is supported by the CSP. */
		KCspData=0x04,
	/** Indicates that display of fax call option menu is supported by the CSP. */
		KCspFax=0x08,
	/** Indicates that display of the menu option to send a Short Message of type Email 
	is supported by the CSP. */
		KCspSMMOEmail=0x10,
	/** Indicates that display of the menu option to send a Short Message of type Paging 
	is supported by the CSP. */
		KCspSMMOPaging=0x20,
	/** Indicates that display of the menu option for manual PLMN selection is supported 
	by the CSP. */
		KCspPLMNMode=0x80,
		};

	

	class TMobilePhoneCspFileV1 : public TMultimodeType
	/** Defines contents of the CSP (Customer Service Profile) on the SIM. The profile 
	consists of the sum of the respective enums.

	@see GetCustomerServiceProfile()
	@publishedPartner
	@released*/
		{
	public:
	/** Constructor. */
		IMPORT_C TMobilePhoneCspFileV1();

	/** Sum of the TCspCallOffering. */
		TUint8	iCallOfferingServices;
	/** Sum of the TCspCallRestriction. */
		TUint8	iCallRestrictionServices;
	/** Sum of the TCspOtherSuppServices. */
		TUint8	iOtherSuppServices;
	/** Sum of the TCspCallCompletion. */
		TUint8	iCallCompletionServices;
	/** Sum of the TCspTeleservices. */
		TUint8  iTeleservices;
	/** Sum of the TCspCPHSTeleservices. */
		TUint8	iCphsTeleservices;
	/** Sum of the TCspCPHSFeatures. */
		TUint8	iCphsFeatures;
	/** Sum of the TCspNumberIdentification. */
		TUint8	iNumberIdentServices;
	/** Sum of the TCspPhase2PlusServices. */
		TUint8	iPhase2PlusServices;
	/** Sum of the TCspValueAdded. */
		TUint8	iValueAddedServices;
		};

/** A typedef'd packaged TMobilePhoneCspFileV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneCspFileV1> TMobilePhoneCspFileV1Pckg;

	IMPORT_C void GetCustomerServiceProfile(TRequestStatus& aReqStatus, TDes8& aCsp) const;

/** SIM/USIM/CDMA Service Table.

Modes: Common */
	enum TSSTServices1To8
		{
	/** Indicates that disabling PIN1 is supported by the ICC. */
		KSstPin1Disable=0x01,
	/** Indicates that storage of Abbreviated Dialling Numbers within this ICC is supported. */
		KSstADN=0x02,
	/** Indicates that the Fixed Dialling Numbers service and the storage of FDN numbers
	within this ICC is supported. */
		KSstFDN=0x04,
	/** Indicates that the Short Message Service and the storage of short messages within 
	this ICC is supported.
	
	Modes: Common */
		KSstSMS=0x08,
	/** Indicates that the Advice of Charge service is supported by this ICC.
	
	Modes: GSM/WCDMA */
		KSstAoC=0x10,
	/** Indicates that the storage of Configuration Capability Parameters associated 
	with an AND, FDN, MSISDN, LND or SDN is supported by this ICC.
	
	Modes: GSM/WCDMA */
		KSstCCP=0x20,
	/** Indicates that storage of a preferred network list is supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSstPLMNSelector=0x40
		};

/** SIM/USIM/CDMA Service Table (continued).

Modes: GSM/WCDMA */
	enum TSSTServices9To16
		{
	/** Indicates that storage of MSISDN (own numbers) numbers within this ICC is supported.
	
	Modes: GSM/WCDMA */
		KSstMSISDN=0x01,
	/** Indicates that storage of extended (greater than 20 digits) ADN, LND and MSISDN
	numbers within this ICC is supported.
	
	Modes: Common */
		KSstExt1=0x02,
	/** Indicates that storage of extended (greater than 20 digits) FDN numbers within 
	this ICC is supported.
	
	Modes: Common */
		KSstExt2=0x04,
	/** Indicates that storage of SMS parameter records within this ICC is supported.
	
	Modes: Common */
		KSstSMSP=0x08,
	/** Indicates that storage of Last Numbers Dialled within this ICC is supported.
	
	Modes: Common */
		KSstLND=0x10,
	/** Indicates that the storage of Cell Broadcast message identifiers is supported 
	within this ICC.
	
	Modes: GSM/WCDMA */
		KSstCBMI=0x20,
	/** Indicates that access to the GID1 file is supported within this ICC.
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSstGID1=0x40,
	/** Indicates that access to the GID2 file is supported within this ICC.
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSstGID2=0x80
		};
	
/** SIM/USIM/CDMA Service Table (continued).

v1.0 of Multimode ETel API does not support this feature

Modes: Common */
	enum TSSTServices17To24
		{
	/** Indicates that access to the Service Provider Name within ICC is supported.
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: Common */
		KSstSPName=0x01,
	/** Indicates that storage of Service Dialling Numbers within ICC is supported.
	
	Modes: Common */
		KSstSDN=0x02,
	/** Indicates that storage of extended (greater than 20 digits) SDN numbers within 
	this ICC/RUIM is supported.
	
	Modes: Common */
		KSstExt3=0x04,
	/** Indicates that access to the VGCS group identifier list within ICC is supported.
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSstVGCSList=0x10,
	/** Indicates that access to the VBS group identifier list within ICC is supported.
	
	v1.0 of Multimode ETel API does not support this feature

	Modes: GSM/WCDMA */
		KSstVBSList=0x20,
	/** Indicates that the enhanced Multi-Level Precedence and Pre-emption service is 
	supported by ICC
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSsteMLPP=0x40,
	/** Indicates that automatic answer for eMLPP is supported by ICC
	
	v1.0 of Multimode ETel API does not support this feature
	
	Modes: GSM/WCDMA */
		KSstAnswereMLPP=0x80
		};

/** SIM/USIM/CDMA Service Table (continued).

Modes: GSM/WCDMA */
	enum TSSTServices25To32
		{
	/** Indicates that SAT SMS-CB data download is supported by ICC. */
		KSstSmsCbDataDownload=0x01,
	/** Indicates that SAT SMS-PP data download is supported by ICC. */
		KSstSmsPpDataDownload=0x02,
	/** Indicates that SAT menu selection is supported by ICC.
	
	SAT ETel API provides this feature. */
		KSstMenuSelection=0x04,
	/** Indicates that SAT call control is supported by ICC.
	
	SAT ETel API provides this feature. */
		KSstCallControl=0x08,
	/** Indicates that SAT pro-active SIM is supported by ICC.
	
	SAT ETel API provides this feature. */
		KSstProactiveSim=0x10,
	/** Indicates ICC storage of ranges of Cell Broadcast Message Identifiers is supported. */
		KSstCBMIRanges=0x20,
	/** Indicates ICC storage of Barred Dialling Numbers is supported. */
		KSstBDN=0x40,
	/** Indicates ICC storage of extended (greater than 20 digits) BDN numbers is supported. */
		KSstExt4=0x80
		};

/** SIM/USIM/CDMA Service Table (continued).

Modes: GSM/WCDMA */
	enum TSSTServices33To40
		{
	/** Indicates depersonalisation control keys are supported by ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstDepersonalisationKeys=0x01,
	/** Indicates co-operative network list are supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstCooperativeNetworks=0x02,
	/** Indicates Short Message Status Reports are supported by ICC. */
		KSstSMStatusReports=0x04,
	/** Indicates network's indication of alerting is supported by ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstNetworkIndAlerting=0x08,
	/** Indicates outgoing SM control by SAT is supported by ICC.
	
	SAT ETel API provides this feature. */
		KSstMoSmControlBySim=0x10,
	/** Indicates that GPRS is supported by this ICC.
	
	GPRS ETel API provides GPRS functionality. */
		KSstGprs=0x20,
	/** Indicates that Image files are supported by this ICC.
	
	SAT ETel API provides this feature. */
		KSstImage=0x40,
	/** Indicates that SoLSA in supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature */
		KSstSoLSA=0x80
		};

/** SIM/USIM/CDMA Service Table (continued).

Modes: GSM/WCDMA */
	enum TSSTServices41To48
		{
	/** Indicates that USSD string data is supported in SAT Call Control by this ICC.
	
	SAT ETel API provides this feature. */
		KSstUssdStringInCallControl=0x01,
	/** Indicates that RUN AT COMMAND is supported in SAT by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature */
		KSstRunATCommand=0x02,
	/** Indicates that PLMN selector list with access technology is supported by this 
	ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstPlmnSelectorListWithAccessTechnology=0x04,
	/** Indicates that OPLMN selector list with access technology is supported by this
	ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstOplmnSelectorListWithAccessTechnology=0x08,
	/** Indicates that HPLMN access technology is supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstHplmnAccessTechnology=0x10,
	/** Indicates that CPBCCH information is supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstCpbcchInformation=0x20,
	/** Indicates that Investigation Scan is supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstInvestigationScan=0x40,
	/** Indicates that extended capability configuration parameters are supported by 
	this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstExtendedCcp=0x80
		};

/** SIM/USIM/CDMA Service Table (continued).

Modes: GSM/WCDMA */
	enum TSSTServices49To56
		{
	/** Indicates Mobile Execution Environment services are supported by this ICC */
		KSstMExE=0x01,
	/** Indicates that RPLMN last used access technology is supported by this ICC.
	
	v1.0 of Multimode ETel API does not support this feature. */
		KSstRplmnLastUsedAccessTechnology=0x02
		};

/** USIM service table. */
	enum TUSTServices1To8
		{
	/** Indicates that the local phonebook is supported by the USIM. Local phonebook 
	means a phonebook that is specific to a USIM Application, as opposed to the 
	global phonebook which is located at the DF Telecom level on the UICC and 
	not attached to a USIM Application. */
		KUstLocalPhBk=0x01,
	/** Indicates that the Fixed Dialling Numbers (FDN) service and the storage of 
	FDN numbers within this USIM is supported. */
		KUstFDN=0x02,
	/** Indicates that the Extension 2 is supported by the USIM. Extension 2 provides 
	extension data for Fixed Dialling Numbers. */
		KUstExt2=0x04,
	/** Indicates that the Service Dialling Numbers are supported by the USIM. */
		KUstSDN=0x08,
	/** Indicates that the Extension 3 is supported by the USIM. Extension 3 provides 
	extension data for Service Dialling Numbers. */
		KUstExt3=0x10,
	/** Indicates that the Barred Dialling Numbers are supported by the USIM. */
		KUstBDN=0x20,
	/** Indicates that the Extension 4 is supported by the USIM. Extension 4 provides 
	extension data for Barred Dialling Numbers. */
		KUstExt4=0x40,
	/** Indicates that the outgoing call information (OCI and OCT) are supported by 
	the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstOugoingCallInfo=0x80
		};
	
/** USIM service table (continued). */
	enum TUSTServices9To16
		{
	/** Indicates that the incoming call information (ICI and ICT) are supported by 
	the USIM
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstIncomingCallInfo=0x01,
	/** Indicates that Short Message Storage is supported by the USIM. */
		KUstSMS=0x02,
	/** Indicates that Short Message Status Reports are supported by the USIM. */
		KUstSMSR=0x04,
	/** Indicates that Short Message Service Parameters are supported by the USIM. */
		KUstSMSP=0x08,
	/** Indicates that Advice Of Charge is supported by the USIM. */
		KUstAoC=0x10,
	/** Indicates that Capability Configuration Parameters are supported by the USIM. */
		KUstCCP=0x20,
	/** Indicates that Cell Broadcast Message Identifier is supported by the USIM. */
		KUstCBMI=0x40,
	/** Indicates that Cell Broadcast Message Identifier Ranges are supported by the 
	USIM. */
		KUstCBMIRanges=0x80
		};

/** USIM service table (continued). */
	enum TUSTServices17To24
		{
	/** Indicates that Group Identifier Level 1 is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstGID1=0x01,
	/** Indicates that Group Identifier Level 2 is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstGID2=0x02,
	/** Indicates that Service Provider Name is supported by the USIM. */
		KUstSPN=0x04,
	/** Indicates that user controlled PLMN selector with Access Technology is supported
	by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstPLMNSelAccessTech=0x08,
	/** Indicates that MSISDN is supported by the USIM. */
		KUstMSISDN=0x10,
	/** Indicates that Image is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. This enum value is reserved for 
	future API use. */
		KUstIMG=0x20,
		//0x40 is a reserved value
	/** Indicates that enhanced Multi Level Precedence and Pre-emption Service is supported 
	by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUsteMLPP=0x80
		};

/** USIM service table (continued). */
	enum TUSTServices25To32
		{
	/** Indicates that Automatic Answer for eMLPP is supported by the USIM.
	
	Note: v1.0 and v2.0 of Multimode ETel API do not support this feature. */
		KUstAnswereMLPP=0x01,
		//0x02 is a reserved value
	/** Indicates that GSM Access is supported by the USIM */
		KUstGSMAccess=0x04,
	/** Indicates that Data download via SMS-PP is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. */
		KUstSMSPpDataDownload=0x08,
	/** Indicates that Data download via SMS-CB is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. */
		KUstSMSCbDataDownload=0x10,
	/** Indicates that Call Control by USIM is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. */
		KUstCallControl=0x20,
	/** Indicates that MO-SMS Control by USIM is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. */
		KUstMoSmControl=0x40,
	/** Indicates that the proactive command RUN AT COMMAND is supported by the USIM.
	
	Note: (U)SAT ETel API provides this feature. */
		KUstPCmdRunAtCommand=0x80		
		};

/** USIM service table (continued). */
	enum TUSTServices33To40
		{
	/** Should always be present as specified by 3 GPP spec. */
		KUstAlways=0x10,
	/** Indicates that the Enabled Service Table is supported by the USIM. */
		KUstEST=0x02,
	/** Indicates that APN Control List is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstACL=0x04,
	/** Indicates that the Depersonalisation Control Keys are supported by the USIM.
	
	Note: v2.0 of Multimode ETel API does not support this feature. */
		KIstDepersonalisationKeys =0x08,
	/** Indicates that the Co-operative Network List is supported by the USIM.

	Note: v2.0 of Multimode ETel API does not support this feature. */
		KUstCooperativeNetwork=0x10,
	/** Indicates that GSM Security Context is supported by the USIM. */
		KUstGSMSecurityContext=0x20,
	/** Indicates that CPBCCH Information is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstCPBCCHInfo=0x40,
	/** Indicates that Investigation Scan is supported by the USIM.
	
	Note:v2.0 of Multimode ETel API do not support this feature. */
		KUstInvestigationScan=0x80
		};

/** USIM service table (continued). */
	enum TUSTServices41To48
		{
	/** Indicates that MExE is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstMExE=0x01,
	/** Indicates that Operator controlled PLMN selector with Access Technology is 
	supported by the USIM.
	
	N.B .v2.0 of Multimode ETel API do not support this feature. */
		KUstOperatorPLMNSelector=0x02,
	/** Indicates that HPLMN selector with Access Technology is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstHPLMNSelAccessTech=0x04,
	/** Indicates that Extension 5 is supported by the USIM. Provides support for extension 
	data for MSISDN. */
		KUstExt5=0x08,
	/** Indicates that PLMN Network Name is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstPLMNNetworkName=0x10,
	/** Indicates that Operator PLMN List is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstOperatorPLMNList=0x20,
	/** Indicates that Mailbox Dialling Numbers are supported by the USIM. */
		KUstMDN=0x40,
	/** Indicates that Message Waiting Indication Status is supported by the USIM. */
		KUstMWISo=0x80
		};

/** USIM service table (continued). */
	enum TUSTServices49To56
		{
	/** Indicates that Call forwarding indication status is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstCFIS=0x01,
	/** Indicates that RPLMN last-used access technology is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstRPLMN=0x02,
	/** Indicates that Service provider display information is supported by the USIM.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KUstSPDI=0x04,
	    KUstMMS=0x08,
	    KUstExt8=0x10,
	    KUstCConGPRS=0x20,
	    KUstMMSUCP=0x40
		};

/** Enabled Services Table. */
	enum TESTServices1To8
		{
	/** Indicates that FDN service is activated. */
		KEstFDN=0x01,
	/** Indicates that BDN service is activated. */
		KEstBDN=0x02,
	/** Indicates that the APN Control List service is activated.
	
	Note: v2.0 of Multimode ETel API do not support this feature. */
		KEstACL=0x04
		};

/** Get Service Table.

Modes: GSM/WCDMA */
	enum TMobilePhoneServiceTable
		{
	/** Retrieve SIM service table on SIM (or from GSM application on UICC).
	
	Modes: GSM/WCDMA */
		ESIMServiceTable,
	/** Retrieve USIM service table from active USIM application on UICC.
	
	Modes: WCDMA */
		EUSIMServiceTable,
	/** Retrieve CDMA service table on R-UIM.
	
	Modes: CDMA */
		ECDMAServiceTable,
	/** USIM Enabled Services Table to be used in conjunction with the USIM Service 
	Table.
	
	Modes: WCDMA */
		EUSIMEnabledServiceTable
		};

	
	class TMobilePhoneServiceTableV1 : public TMultimodeType
	/** Defines contents of the specified Service Table on the ICC.

	@see GetServiceTable()
	@publishedPartner
	@released
	 */
		{
	public:
		IMPORT_C TMobilePhoneServiceTableV1();

	/** Sum of the TSSTServices1To8 capability constants. */
		TUint8 iServices1To8;
	/** Sum of the TSSTServices9To16 capability constants. */
		TUint8 iServices9To16;
	/** Sum of the TSSTServices17To24 capability constants. */
		TUint8 iServices17To24;
	/** Sum of the TSSTServices25To32 capability constants. */
		TUint8 iServices25To32;
	/** Sum of the TSSTServices33To40 capability constants. */
		TUint8 iServices33To40;
	/** Sum of the TSSTServices41To48 capability constants. */
		TUint8 iServices41To48;
	/** Sum of the TSSTServices49To56 capability constants. */
		TUint8 iServices49To56;
		};

/** A typedef'd packaged TMobilePhoneServiceTableV1 passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneServiceTableV1> TMobilePhoneServiceTableV1Pckg;

	enum { KAIDSize=16 };

/** A typedef'd buffer to hold the application identifier (AID) that identifies 
the USIM application in a UICC. The AID consists of a Registered application 
provider IDentifier (RID) of 5Â bytes and a Proprietary application Identifier 
eXtension (PIX) of up to 11 bytes. */
	typedef TBuf8<KAIDSize> TAID; 

	class TMobilePhoneServiceTableV2 : public TMobilePhoneServiceTableV1
/** Defines contents of the specified Service Table on the ICC for the v2.0 version 
of the API. 
*/
		{
	public:
		IMPORT_C TMobilePhoneServiceTableV2();
	public:
	/** The application identifier. */
		TAID   iAID;
		};

/** A typedef'd packaged TMobilePhoneServiceTableV2 passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneServiceTableV2> TMobilePhoneServiceTableV2Pckg;
 
	IMPORT_C void GetServiceTable(TRequestStatus& aReqStatus, TMobilePhoneServiceTable aTable, TDes8& aTableData) const;
	
	
	/***********************************************************************************/
	//
	// MobilePhonePower functional unit
	//
	/***********************************************************************************/

/** Phone supported battery information.

Modes: Common */
	enum TMobilePhoneBatteryCaps
		{
	/** Phone supports requests to get the current battery information. */
		KCapsGetBatteryInfo=0x00000001,
	/** Phone supports requests for notification of change in battery information. */
		KCapsNotifyBatteryInfoChange=0x00000002
		};

	IMPORT_C TInt GetBatteryCaps(TUint32& aCaps) const; 

/** The mobile phone battery status.

Modes: Common */
	enum TMobilePhoneBatteryStatus
		{
	/** The TSY can not determine the phone's current power status. */
		EPowerStatusUnknown,
	/** The phone is currently powered by a battery. */
		EPoweredByBattery,
	/** A battery is connected, but the phone is externally powered. */
		EBatteryConnectedButExternallyPowered,
	/** No battery is connected. */
		ENoBatteryConnected,
	/** Power fault. */
		EPowerFault
		};

	class TMobilePhoneBatteryInfoV1 : public TMultimodeType
/** Defines contents of the battery status of the phone.

@see GetBatteryInfo()
@see NotifyBatteryInfoChange()
*/
		{
	public:
		IMPORT_C TMobilePhoneBatteryInfoV1();
	public:
	/** The power and battery status.
	
	@see TMobilePhoneBatteryStatus */
		TMobilePhoneBatteryStatus iStatus;
	/** The percentage battery charge level. */
		TUint iChargeLevel;
		};

	IMPORT_C void GetBatteryInfo(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const;
	IMPORT_C void NotifyBatteryInfoChange(TRequestStatus& aReqStatus, TMobilePhoneBatteryInfoV1& aInfo) const;

	
	/***********************************************************************************/
	//
	// MobilePhoneSignal functional unit
	//	
	/***********************************************************************************/

/** The mobile phone signal strength capabilities.

Modes: Common */
	enum TMobilePhoneSignalCaps
		{
	/** Phone supports requests to get the current signal strength. */
		KCapsGetSignalStrength=0x00000001,
	/** Phone supports requests for notification of change in signal strength. */
		KCapsNotifySignalStrengthChange=0x00000002
		};

	IMPORT_C TInt GetSignalCaps(TUint32& aCaps) const; 
	IMPORT_C void GetSignalStrength(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const;
	IMPORT_C void NotifySignalStrengthChange(TRequestStatus& aReqStatus, TInt32& aSignalStrength, TInt8& aBar) const;

	/***********************************************************************************/
	//
	// MobilePhoneIndicator functional unit
	//
	/***********************************************************************************/
	
/** The mobile phone indicator capabilities supported.

Modes: Common */
	enum TMobilePhoneIndicatorCaps
		{
	/** Phone supports requests to get the current value of all supported indicators. */
		KCapsGetIndicator=0x00000001,
	/** Phone supports requests for notification of change in the supported indicators. */
		KCapsNotifyIndicatorChange=0x00000002
		};

/** The mobile phone indicators.

Modes Common */
	enum TMobilePhoneIndicators
		{
	/** If bit-flag is set to '1' indicates that the battery charger is connected to 
	the phone. If bit-flag is set to '0' indicates that the battery charger is 
	disconnected. */
		KIndChargerConnected=0x00000001,
	/** If bit-flag is set to '1' indicates that network service is available. If bit-flag 
	is set to '0' indicates that network service is unavailable. */
		KIndNetworkAvailable=0x00000002,
	/** If bit-flag is set to '1' indicates that a call is in progress. If set to '0' 
	indicates that a call is not in progress. */
		KIndCallInProgress=0x00000004
		};

	IMPORT_C TInt GetIndicatorCaps(TUint32& aActionCaps, TUint32& aIndCaps) const; 
	IMPORT_C void GetIndicator(TRequestStatus& aReqStatus, TUint32& aIndicator) const;
	IMPORT_C void NotifyIndicatorChange(TRequestStatus& aReqStatus, TUint32& aIndicator) const;

	
	/***********************************************************************************/
	//
	// MobilePhoneIdentity functional unit
	//
	/***********************************************************************************/
	
/** Defines Identity Capabilities.

Modes: Common */
	enum TMobilePhoneIdentityCaps
		{
	/** Phone can return the identity of its manufacturer. */
		KCapsGetManufacturer=0x00000001,
	/** Phone can return the identity of its model. */
		KCapsGetModel=0x00000002,
	/** Phone can return the identity of its revision. */
		KCapsGetRevision=0x00000004,
	/** Phone can return the identity of its serial number. */
		KCapsGetSerialNumber=0x00000008,
	/** Phone can return the identity of its subscriber. */
		KCapsGetSubscriberId=0x00000010
		};

	IMPORT_C TInt GetIdentityCaps(TUint32& aCaps) const;

	enum {	KPhoneManufacturerIdSize=50	};
	enum {	KPhoneModelIdSize=50 };
	enum {	KPhoneRevisionIdSize=50	};
	enum {	KPhoneSerialNumberSize=50 };
	
	class TMobilePhoneIdentityV1 : public TMultimodeType
/** Defines the mobile phone identity.

@see GetPhoneId() */
		{
	public:
		IMPORT_C TMobilePhoneIdentityV1();
	public:
	/** Phone manufacturer identification, in character string format. */
		TBuf<KPhoneManufacturerIdSize> iManufacturer;
	/** Phone model identification, in character string format. */
		TBuf<KPhoneModelIdSize> iModel;
	/** Phone revision identification, in character string format. */
		TBuf<KPhoneRevisionIdSize> iRevision;
	/** Phone serial number (IMEI or ESN), in character string format. */
		TBuf<KPhoneSerialNumberSize> iSerialNumber;
		};

	IMPORT_C void GetPhoneId(TRequestStatus& aReqStatus, TMobilePhoneIdentityV1& aId) const;

	enum {	KIMSISize = 15 };

/** A typedef'd buffer to hold the mobile phone subscriber id. */
	typedef TBuf<KIMSISize> TMobilePhoneSubscriberId;

	IMPORT_C void GetSubscriberId(TRequestStatus& aReqStatus, TMobilePhoneSubscriberId& aId) const;

	/***********************************************************************************/
	//
	// MobilePhoneDTMF functional unit
	//
	/***********************************************************************************/
	
/** DTMF Capabilities.

Modes: Common */
	enum TMobilePhoneDTMFCaps
		{
	/** Capability to send a string of DTMF tones, containing one or more tone(s). */
		KCapsSendDTMFString=0x00000001,
	/** Capability to send one DTMF tone, using start and stop DTMF tone function member. */
		KCapsSendDTMFSingleTone=0x00000002,
		};
		
	/**
	DTMF tone operation event.
	*/
	enum TMobilePhoneDTMFEvent
		{
		/**
		 Start sending of a Dtmf tone operation has been acknowledged from the MSC.
		*/
		EStartDtmfTone,
		/**
		 Stop sending of a Dtmf tone operation has been acknowledged from the MSC.
		*/
		EStopDtmfTone,
		};
		

	IMPORT_C TInt GetDTMFCaps(TUint32& aCaps) const; 
	IMPORT_C void NotifyDTMFCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

	IMPORT_C void SendDTMFTones(TRequestStatus& aReqStatus, const TDesC& aTones) const;
	IMPORT_C void ReadDTMFTones(TRequestStatus& aReqStatus, TDes& aTones) const;
	IMPORT_C TInt StartDTMFTone(TChar aTone) const;
	IMPORT_C TInt StopDTMFTone() const;

	IMPORT_C void NotifyStopInDTMFString(TRequestStatus& aRequestStatus) const;
	IMPORT_C TInt ContinueDTMFStringSending(TBool aContinue) const;
	IMPORT_C void NotifyDTMFEvent(TRequestStatus& aReqStatus, TMobilePhoneDTMFEvent& aEvent) const;

	/***********************************************************************************/
	//
	// MobilePhoneNetwork functional unit
	//
	/***********************************************************************************/
	
/** Defines Network Capabilities.

Modes: Common */
	enum TMobilePhoneNetworkCaps
		{
	/** The phone supports retrieval of current registration status. */
		KCapsGetRegistrationStatus=0x00000001,
	/** The phone supports notifications of change in registration status. */
		KCapsNotifyRegistrationStatus=0x00000002,
	/** The phone supports retrieval of current mode. */
		KCapsGetCurrentMode=0x00000004,
	/** The phone supports notification of change in mode. */
		KCapsNotifyMode=0x00000008,
	/** The phone supports retrieval of current network information. */
		KCapsGetCurrentNetwork=0x00000010,
	/** The phone supports notification of change of current network. */
		KCapsNotifyCurrentNetwork=0x00000020,
	/** The phone supports retrieval of home network information. */
		KCapsGetHomeNetwork=0x00000040,
	/** The phone supports retrieval of a list of detected networks. */
		KCapsGetDetectedNetworks=0x00000080,
	/** The phone supports manual network selection mode. */
		KCapsManualNetworkSelection=0x00000100,
	/** The phone supports retrieval of time and date information (NITZ) received from 
	the network. */
		KCapsGetNITZInfo=0x00000200,
	/** The phone supports notification of new updates of time & date information (NITZ) 
	received from the network. */
		KCapsNotifyNITZInfo=0x00000400
		};

	IMPORT_C TInt GetNetworkCaps(TUint32& aCaps) const;

/** Defines Current Network Modes.

Modes: Common */
	enum TMobilePhoneNetworkMode
		{
	/** Network mode is unknown.
	
	Modes: Common */
		ENetworkModeUnknown,
	/** ME is not registered.
	
	Modes: Common */
		ENetworkModeUnregistered,
	/** GSM/GPRS or DCS1800 network. */
		ENetworkModeGsm,
	/** AMPS network.
	
	Modes: CDMA */
		ENetworkModeAmps,
	/** CDMA (IS-95) network.
	
	Modes: CDMA */
		ENetworkModeCdma95,
	/** CDMA (cdma2000) network.
	
	Modes: CDMA */
		ENetworkModeCdma2000,
	/** WCDMA  (UTRA Frequency Division Duplex (FDD)) network.
	
	Modes: WCDMA */
		ENetworkModeWcdma,
	/** TD-CDMA (UTRA Time Division Duplex (TDD)) network.
	
	Modes: WCDMA */	
		ENetworkModeTdcdma
		};

	IMPORT_C TInt GetCurrentMode(TMobilePhoneNetworkMode& aNetworkMode) const;
	IMPORT_C void NotifyModeChange(TRequestStatus& aReqStatus, TMobilePhoneNetworkMode& aNetworkMode) const;

/** Phone network status.

Modes: Common */
	enum TMobilePhoneNetworkStatus
		{
	/** Status is unknown. */
		ENetworkStatusUnknown,
	/** A network that the ME is allowed to register to. */
		ENetworkStatusAvailable,
	/** The currently registered network. */
		ENetworkStatusCurrent,
	/** A network that the ME is not allowed to register to. */
		ENetworkStatusForbidden
		};

/** Mobile phone network band information.

Modes: CDMA */
	enum TMobilePhoneNetworkBandInfo
		{
	/** The current band and band class is unknown. */
		EBandUnknown,
	/** The network operates at 800MHz on Band A. */
		E800BandA,
	/** The network operates at 800MHz on Band B. */
		E800BandB,
	/** The network operates at 800MHz on Band C. */
		E800BandC,
	/** The network operates at 1900MHz on Band A. */
		E1900BandA,
	/** The network operates at 1900MHz on Band B. */
		E1900BandB,
	/** The network operates at 1900MHz on Band C. */
		E1900BandC,
	/** The network operates at 1900MHz on Band D. */
		E1900BandD,
	/** The network operates at 1900MHz on Band E. */
		E1900BandE,
	/** The network operates at 1900MHz on Band F. */
		E1900BandF
		};

/** A typedef'd buffer to hold the network display tag */
	typedef TBuf<30> TMobilePhoneNetworkDisplayTag;
/** A typedef'd buffer to hold the network long name. */
	typedef TBuf<20> TMobilePhoneNetworkLongName;		
/** A typedef'd buffer to hold the network short name. */
	typedef TBuf<10> TMobilePhoneNetworkShortName;

/** A typedef'd buffer to hold the network country code. */
	typedef TBuf<4> TMobilePhoneNetworkCountryCode;		// MCC in GSM and CDMA
/** A typedef'd buffer to hold the network identity. */
	typedef TBuf<8> TMobilePhoneNetworkIdentity;		// MNC in GSM and SID or NID in CDMA 

	

	class TMobilePhoneNetworkInfoV1 : public TMultimodeType
	/** Defines information related to a mobile phone network.

	@see GetCurrentNetwork()
	@see NotifyCurrentNetworkChange()
	@see GetHomeNetwork()
	@publishedPartner
	@released */
		{
	public:
		IMPORT_C TMobilePhoneNetworkInfoV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** Mode of the network.
	
	Modes: Common
	
	@see TMobilePhoneNetworkMode */
		TMobilePhoneNetworkMode iMode;
	/** Status of the network
	
	Modes: Common
	
	@see TMobilePhoneNetworkStatus */
		TMobilePhoneNetworkStatus iStatus;
	/** The band and band class of the CDMA network operator.

	Modes: CDMA
	
	@see TMobilePhoneNetworkBandInfo */
		TMobilePhoneNetworkBandInfo iBandInfo;
	/** The MCC of the network.
	
	Modes: Common
	
	@see TMobilePhoneNetworkCountryCode */
		TMobilePhoneNetworkCountryCode iCountryCode;
	/** The system identity (SID) of the CDMA network.
	
	Modes: CDMA
	
	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iCdmaSID;
	/** The system identity (SID) of the AMPS network.
	
	Modes: CDMA
	
	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iAnalogSID;
	/** The network identity (NID in CDMA and MNC in GSM).
	
	Modes: Common
	
	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iNetworkId;
	/** The alpha-tag displayed when this is the serving network.
	
	Modes: Common
	
	@see TMobilePhoneNetworkDisplayTag */
		TMobilePhoneNetworkDisplayTag iDisplayTag;
	/** The short name (up to 10 characters) of the network operator.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkShortName */
		TMobilePhoneNetworkShortName iShortName;
	/** The long name (up to 20 characters) of the network operator.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkLongName */
		TMobilePhoneNetworkLongName iLongName;
		};
	
/** A typedef'd packaged TMobilePhoneNetworkInfoV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneNetworkInfoV1>  TMobilePhoneNetworkInfoV1Pckg;
	
/** The access technology that the network is based on.

Modes: Common */
	enum TMobilePhoneNetworkAccess
		{
	/** This is used when there is no network activity and therefore no RAT active.
	
	Modes: Common */
		ENetworkAccessUnknown,
	/** The access technology is GSM.
	
	Modes: GSM */
		ENetworkAccessGsm,
	/** The access technology is GSM COMPACT. However GSM COMPACT systems which use 
	GSM frequency bands but with the CBPCCH broadcast channel are considered as 
	a separate access technology from GSM.
	
	Modes: GSM */
		ENetworkAccessGsmCompact,
	/** The access technology is UTRAN (UMTS Network).
	
	Modes: WCDMA */
		ENetworkAccessUtran,					
	/** Analogue Cellular 
	
	Modes: CDMA */
		ENetworkAccessAmpsCellular,
	/** CDMA Cellular - Standard channels 

	Modes: CDMA */
		 ENetworkAccessCdmaCellularStdChannel,
	/** CDMA Cellular - Custom channels 

	Modes: CDMA */
		ENetworkAccessCdmaCellularCustomChannel,
	/** CDMA/Analogue Cellular (cdma first then analogue)

	Modes: CDMA */
		ENetworkAccessCdmaAmpsCellular,
	/** CDMA PCS - Using blocks 
	
	Modes: CDMA */
		ENetworkAccessCdmaPcsUsingBlocks,
	/** CDMA PCS - Using channels 
	
	Modes: CDMA */
		ENetworkAccessCdmaPcsUsingNetworkAccessChannels,
	/** CDMA JTACS - Standard channels 
	
	Modes: CDMA */
		ENetworkAccessJTacsStdChannels,
	/** CDMA JTACS - Custom channels 
	
	Modes: CDMA */
		ENetworkAccessJTacsCustomChannels,
	/** CDMA 2GHz band - Using channels 
	
	Modes: CDMA */
		ENetworkAccess2GHzBandUsingChannels,
	/** Generic Acquisition Record for IS-2000 and IS-95 
	
	Modes: CDMA */
		ENetworkAccessGenericAcqRecord2000and95,
	/** Generic Acquisition Record for IS-856
	
	Modes: CDMA */
		ENetworkAccessGenericAcqRecord856
		};

	

	class TMobilePhoneNetworkInfoV2 : public TMobilePhoneNetworkInfoV1
	/** The access technology that the network is based on in version v2.0 of the API. 
	@publishedPartner
	@released*/
		{
	public:
	/** Default constructor. Network access is set to ENetworkAccessUnknown and iExtensionId 
	is set to KETelExtMultimodeV2. */
		IMPORT_C TMobilePhoneNetworkInfoV2();
	
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	
	public:
	/** The type of network access.
	
	@see TMobilePhoneNetworkAccess */
		TMobilePhoneNetworkAccess iAccess;
		};
	
/** A typedef'd packaged TMobilePhoneNetworkInfoV2 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneNetworkInfoV2>  TMobilePhoneNetworkInfoV2Pckg;


	class TMobilePhoneNetworkInfoV5 : public TMobilePhoneNetworkInfoV2
	/** The access technology that the network is based on in version v2.0 of the API. 
	@publishedPartner
	@released*/
		{
	public:
		IMPORT_C TMobilePhoneNetworkInfoV5();
		
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
		
	public:
	/** HSDPA availability indicator. This information is for display 
	indication only and shall not be used for any other purpose.
		
	Modes: WCDMA */
		TBool iHsdpaAvailableIndicator;

	/** EGPRS availability indicator. This information is for display
	indication only and shall not be used for any other purpose.
		
	Modes: GPRS */
		TBool iEgprsAvailableIndicator;
		};

/** A typedef'd packaged TMobilePhoneNetworkInfoV5 for passing through a generic 
API function member. */		
	typedef TPckg<TMobilePhoneNetworkInfoV5> TMobilePhoneNetworkInfoV5Pckg;
	
	class TMobilePhoneLocationAreaV1 : public TMultimodeType
/** Defines the mobile phone location area.

@see GetCurrentNetwork()
@see NotifyCurrentNetworkChange() */
		{
	public:
	/** Constructor. */
		IMPORT_C TMobilePhoneLocationAreaV1();
	public:
	/** Boolean indicating whether the location area is known.
	
	Modes: Common */
		TBool	iAreaKnown;
	/** Location area code.
	
	Modes: GSM/WCDMA */
		TUint	iLocationAreaCode;
	/** Cell identity code.
	
	Modes: GSM/WCDMA */
		TUint	iCellId;
		};

	IMPORT_C void GetCurrentNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const;
	IMPORT_C void NotifyCurrentNetworkChange(TRequestStatus& aReqStatus, TDes8& aNetworkInfo, TMobilePhoneLocationAreaV1& aArea) const;
	IMPORT_C void GetCurrentNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo) const;
	IMPORT_C void NotifyCurrentNetworkChange(TRequestStatus& aReqStatus, TDes8& aNetworkInfo) const;

	IMPORT_C void GetHomeNetwork(TRequestStatus& aReqStatus, TDes8& aNetworkInfo) const;
	IMPORT_C void GetHomeNetworkSearchPeriod(TRequestStatus& aReqStatus, TInt& aSearchIntv) const;
	IMPORT_C void GetLastUsedAccessTechnology(TRequestStatus& aReqStatus, TMobilePhoneNetworkAccess& aAccessTech) const;

/** The registration status of the mobile phone.

Modes: WCDMA */
	enum TMobilePhoneRegistrationStatus
		{
	/** Registration status is unknown. */
		ERegistrationUnknown,
	/** Not registered. The ME can not detect any other networks and is not currently 
	searching a new operator to register to. */
		ENotRegisteredNoService,
	/** Not registered. The ME can detect other networks on which it is possible to 
	make emergency calls only. */
		ENotRegisteredEmergencyOnly,
	/** Not registered, but the ME is currently searching a new operator to register to. */
		ENotRegisteredSearching,
	/** Registered, network busy.
	
	Modes: WCDMA */
		ERegisteredBusy,
	/** Registered on home network. */
		ERegisteredOnHomeNetwork,
	/** Registration denied. */
		ERegistrationDenied,
	/** Registered, roaming. */
		ERegisteredRoaming
		};

	IMPORT_C void GetNetworkRegistrationStatus(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const;
	IMPORT_C void NotifyNetworkRegistrationStatusChange(TRequestStatus& aReqStatus, TMobilePhoneRegistrationStatus& aStatus) const;

/** The network selection function member.

Modes: Common */
	enum TMobilePhoneSelectionMethod
		{
	/** Network selection function member is unknown.
	
	Modes: Common */
		ENetworkSelectionUnknown,
	/** Network is selected automatically by phone.
	
	Modes: Common */
		ENetworkSelectionAutomatic,
	/** Network is selected manually by user.
	
	Modes: GSM/WCDMA */
		ENetworkSelectionManual,
	/** Network selection is restricted to home network only
	
	Modes: CDMA */
		ENetworkSelectionHomeOnly
		};

/** The mobile phone band class preferences.

Modes: CDMA */
	enum TMobilePhoneBandClass
		{
	/** Band class selection is unknown. */
		ENetworkBandClassUnknown,
	/** Phone will select band class A only. */
		ENetworkBandClassAOnly,
	/** Phone will select band class B only. */
		ENetworkBandClassBOnly,
	/** Phone will prefer to select band class A. */
		ENetworkBandClassAPreferred,
	/** Phone will prefer to select band class B. */
		ENetworkBandClassBPreferred
		};

/** The mobile phone network operation mode preferences.

Modes: CDMA */
	enum TMobilePhoneOperation
		{
	/** Network operation mode is unknown. */
		ENetworkOperationUnknown,
	/** Phone will select analog operation only. */
		ENetworkOperationAnalogOnly,
	/** Phone will select digital/CDMA operation only. */
		ENetworkOperationDigitalOnly,
	/** Phone will prefer to select analog operation. */
		ENetworkOperationAnalogPreferred,
	/** Phone will prefer to select digital/CDMA operation. */
		ENetworkOperationDigitalPreferred
		};

	class TMobilePhoneNetworkSelectionV1 : public TMultimodeType
/** The mobile phone network selection preferences.

@see GetNetworkSelectionSetting()
@see SetNetworkSelectionSetting()
@see NotifyNetworkSelectionSettingChange()
@publishedPartner
@released */
		{
	public:
		IMPORT_C TMobilePhoneNetworkSelectionV1();
	public:
	/** Phone's network selection function member.
	
	Modes: Common
	
	@see TMobilePhoneSelectionMethod */
		TMobilePhoneSelectionMethod	iMethod;
	/** Phone's band class setting.
	
	Modes: CDMA
	
	@see TMobilePhoneBandClass */
		TMobilePhoneBandClass		iBandClass;
	/** Phone's CDMA operation mode.
	
	Modes: CDMA
	
	@see TMobilePhoneOperation */
		TMobilePhoneOperation		iOperationMode;
		};

/** A typedef'd packaged TMobilePhoneNetworkSelectionV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneNetworkSelectionV1>  TMobilePhoneNetworkSelectionV1Pckg;

	IMPORT_C TInt GetNetworkSelectionSetting(TDes8& aSetting) const;
	IMPORT_C void SetNetworkSelectionSetting(TRequestStatus& aReqStatus, const TDes8& aSetting) const;
	IMPORT_C void NotifyNetworkSelectionSettingChange(TRequestStatus& aReqStatus, TDes8& aSetting) const;
	
	struct TMobilePhoneNetworkManualSelection
/** The mobile phone manual network selection parameters.

Modes: GSM/WCDMA

@see TMobilePhoneNetworkCountryCode */
		{
	/** The MCC of the network
	
	@see TMobilePhoneNetworkCountryCode */
		TMobilePhoneNetworkCountryCode iCountry;
	/** The MNC of the network
	
	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iNetwork;
		};
	
	IMPORT_C void SelectNetwork(TRequestStatus& aReqStatus, TBool aIsManual, const TMobilePhoneNetworkManualSelection& aManualSelection) const;

	

	 // Used to indicate which TMobilePhoneNITZ fields are currently available
/** The Phone Network Time Zone Capabilities. */
	 enum TMobilePhoneNITZCaps
		{
	/** Universal Time is available in the current network mode. */
		KCapsTimeAvailable      = 0x00000001,
	/** Local time zone is available in the current network mode. */
		KCapsTimezoneAvailable  = 0x00000002,
	/** DST is available in the current network mode. */
		KCapsDSTAvailable       = 0x00000004,
	/** Short name is available in the current network mode. */
		KCapsShortNameAvailable = 0x00000008,
	/** Long name is available in the current network mode. */
		KCapsLongNameAvailable  = 0x00000010
		};

	class TMobilePhoneNITZ : public TDateTime
/** Defines time and date information received from a mobile phone network.

@see GetNITZInfo()
@see NotifyNITZInfoChange()
@publishedPartner
@released */
		{
	public:
		IMPORT_C TMobilePhoneNITZ();
		IMPORT_C TMobilePhoneNITZ(TInt aYear, TMonth aMonth, TInt aDay, TInt aHour, TInt aMinute, TInt aSecond, TInt aMicroSecond);		
	public:
	/** Bitwise sum of TMobilePhoneNITZCaps constants used to indicate which NITZ fields 
	are available.
	
	Modes: Common */
		TInt32	                     iNitzFieldsUsed;
	/** Time zone, expressed in +/- 15 minute offsets from GMT.
	
	Modes: Common */
		TInt                         iTimeZone;
	/** Daylight Saving Time adjustment for summer time. The adjustment for DST 
	can be +1h or +2h.
	
	Modes: GSM/WCDMA */
		TInt	                     iDST;
	/** Network name in "short" representation.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkShortName */
		TMobilePhoneNetworkShortName iShortNetworkId;
	/** Network name in "long" representation.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkLongName */
		TMobilePhoneNetworkLongName	 iLongNetworkId;
		};

	IMPORT_C TInt GetNITZInfo(TMobilePhoneNITZ& aNITZInfo) const;
	IMPORT_C void NotifyNITZInfoChange(TRequestStatus& aReqStatus, TMobilePhoneNITZ& aNITZInfo) const;

	enum { KMaxSPNameSize=16 };
	enum { KMaxPLMNFieldSize=251 };

	enum TDisplayRequirements
		{
		KDisplayPLMNNotRequired	= 0x00000001,
		KDisplayPLMNRequired	= 0x00000002,
		KDisplaySPNRequired		= 0x00000004,
		KDisplaySPNNotRequired	= 0x00000008
		};

	typedef TUint32 TDisplayRequirementsFlags;

	class TMobilePhoneServiceProviderNameV2 : public TMultimodeType
/** Used to retrieve the Service Provider Name from the ICC. The 
SP is actually the entity that provides the service. The SP could have contractual 
agreements with several home PLMN that the ME can register to. The display 
preference of the registered PLMN and/or the SPN on the ME can be defined 
on the UICC.
@publishedPartner
@released */
		{
	public:
		IMPORT_C TMobilePhoneServiceProviderNameV2();
	public:
	/** This parameter specifies if the display of the registered PLMN is required. 
	Can contain a number of flags from RMobilePhone::TDisplayRequirements.
	*/
		TDisplayRequirementsFlags	iDisplayReq;
	/** The name of the service provider. */
		TBuf<KMaxSPNameSize>	iSPName;
		TBuf<KMaxPLMNFieldSize>	iPLMNField;
		}; 

/** A typedef'd packaged TMobilePhoneServiceProviderNameV2 for passing through 
a generic API function member. */
	typedef TPckg<TMobilePhoneServiceProviderNameV2> TMobilePhoneServiceProviderNameV2Pckg;

	IMPORT_C void GetServiceProviderName(TRequestStatus& aReqStatus, TDes8& aName) const;
	
	/**
	Network investigation scan settings.
	*/
	enum TMobilePhoneInvestigationScan
		{
		/**
		Network investigation setting in limited service mode.
		*/
		KNetworkInvLimited = 0x01,
		/**
		Network investigation setting after successful PLMN selection.
		*/
		KNetworkInvAfterPlmnSelection=0x02		
		};
		
	/**
	Network investigation scan events.
	*/
	enum TMobilePhoneInvestigationScanEvent
		{
		/**
		No investigation scan events available.
		*/
		ENetworkInvestigationNoEvent,
		/**
		A higher priority network has been detected, but it does not offer CS Voice.
		*/
		ENetworkInvestigationHighPriorityPlmn
		};
	
	IMPORT_C TInt GetNetworkInvScanSetting(TMobilePhoneInvestigationScan & aSetting) const;
	IMPORT_C void NotifyNetworkInvScanChange(TRequestStatus& aReqStatus, TMobilePhoneInvestigationScan& aSetting) const;
	IMPORT_C void NotifyNetworkInvScanEvent(TRequestStatus& aReqStatus, TMobilePhoneInvestigationScanEvent& aEvent) const;


	/** 251 bytes is the maximum number of octets in an L3 message as defined in3GPP TS 44.006. */
	enum { KMaxNetworkNameFieldSize = 251 };
	
	class TMobilePhoneNetworkNameV3 : public TMultimodeType
	/**
	Class containing short, long network names and location information for a PLMN.
	*/
		{
	public:
		IMPORT_C TMobilePhoneNetworkNameV3();
	public:
		/**
		The long name (up to 20 characters) of the network operator.
		*/
		TMobilePhoneNetworkLongName	 iLongName;
		/**
		The short name (up to 10 characters) of the network operator.
		*/
		TMobilePhoneNetworkShortName	 iShortName;
		/**
		This buffer contains other long and short names for the registered PLMN coded as TLV objects.
		*/
		TBuf<KMaxNetworkNameFieldSize>	 iOtherNames;
		};
		
	/**
 	Packaging typedef for TMobilePhoneNetworkNameV3 class.
 	*/	
	typedef TPckg<TMobilePhoneNetworkNameV3>  TMobilePhoneNetworkNameV3Pckg;
	
	
	class  TMobilePhoneOPlmnV3 : public TMultimodeType
	/**
	Class containing network name information.
	*/
		{
	public:
		IMPORT_C TMobilePhoneOPlmnV3();
	public:
		/**
		The MCC of the registered PLMN, with "wild" values specified for the particular digits of the code.
		*/
		TMobilePhoneNetworkCountryCode iCountryCode;
		/**
		The MNC of the registered PLMN, with "wild" values specified for the particular digits of the code.
		*/
		TMobilePhoneNetworkIdentity iNetworkId;
		/**
		The id of the Network Name to be displayed for the (following) location area codes.
		*/
		TUint32 iPNNid;
		/**
		First Location area code for defining the entire range of LACs for the registered PLMN.
		*/
		TUint iFirstLocationAreaCode;
		/**
		Last Location area code defining the entire range of LACs for the registered PLMN.
		*/
		TUint iLastLocationAreaCode;
		
		};
		
	/**
 	Packaging typedef for TMobilePhoneOPlmnV3 class.
 	*/	
	typedef TPckg<TMobilePhoneOPlmnV3>  TMobilePhoneOPlmnV3Pckg;
	
	IMPORT_C void GetCurrentNetworkName(TRequestStatus& aReqStatus, TDes8& aNetworkName, TDes8& aLocInfo) const;
	
	/**
	Identifiers for different access technologies.
	*/
	enum TMobilePhoneNetworkAccessCaps
		{
		/**
		No network activity.
		*/
		KNetworkAccessUnknown=0x0000,
		/**
		Access technology is GSM.
		*/
		KNetworkAccessGsm=0x8000,
		/**
		Access technology is GSM COMPACT.
		*/
		KNetworkAccessGsmCompact=0x4000,
		/**
		Access technology is UTRAN (UMTS only).
		*/
		KNetworkAccessUtran=0x0080
		};

	typedef TUint32 TMobilePhoneNetworkAccessCapsFlags;
		
	class TMobilePreferredNetworkEntryV3 : public TMultimodeType
	/**
	Defines information for a preferred network.
	*/
		{
	public:
		IMPORT_C TMobilePreferredNetworkEntryV3();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		/**
		Access Technology supported.
		Can contain a number of flags from RMobilePhone::TMobilePhoneNetworkAccessCaps.
		*/
		TMobilePhoneNetworkAccessCapsFlags iAccess;
		/**
		Editable preferences in the User-controlled Networks List with Access Technology.
		*/
		TBool iUserDefined;
		/**
		The MCC of the network.
		*/
		TMobilePhoneNetworkCountryCode iCountryCode;
		/**
		The MNC of the network.
		*/
		TMobilePhoneNetworkIdentity iNetworkId;
		};
		
	IMPORT_C void StorePreferredNetworksListL(TRequestStatus& aReqStatus, CMobilePhoneStoredNetworkList* aList) const;
	IMPORT_C void NotifyPreferredNetworksListChange(TRequestStatus& aReqStatus) const;
		
	/***********************************************************************************/		
	//
	// Mobile Multimedia Call Settings functional unit
	//
	/***********************************************************************************/
	
/** An enumerated list of settings for multimedia calls. */
	enum TMobilePhoneMultimediaSettings
		{
	/** Accept all incoming multimedia calls with the fallback option enabled. (default). */
		EAcceptMMCallsVoiceFallback,
	/** Accept all incoming multimedia calls, but do not accept voice fallback. */
		EAcceptMMCallsNoFallback,
	/** Reject all incoming multimedia calls. */
		ERejectMMCalls,
	/** Reject all incoming multimedia calls, but drop to voice instead. */
		EAnswerMMCallsAsVoice
		};

	IMPORT_C void SetMultimediaCallPreference(TRequestStatus& aReqStatus, TMobilePhoneMultimediaSettings aMmSettings) const;
	IMPORT_C TInt GetMultimediaCallPreference(TMobilePhoneMultimediaSettings& aMmSettings) const;
	IMPORT_C void NotifyMultimediaCallPreferenceChange(TRequestStatus& aReqStatus, TMobilePhoneMultimediaSettings& aMmSettings);

	/***********************************************************************************/	
	//
	// MobilePrivacy functional unit
	//
	/***********************************************************************************/
	
/** The mobile phone privacy settings.

Modes: CDMA */
	enum TMobilePhonePrivacy
		{
	/** The privacy setting is unspecified. */
		EPrivacyUnspecified,
	/** The privacy setting is set to ON. */
		EPrivacyOn,
	/** The privacy setting is set to OFF. */
		EPrivacyOff
		};

	IMPORT_C TInt GetDefaultPrivacy(TMobilePhonePrivacy& aSetting) const;
	IMPORT_C void SetDefaultPrivacy(TRequestStatus& aReqStatus, TMobilePhonePrivacy aSetting) const;
	IMPORT_C void NotifyDefaultPrivacyChange(TRequestStatus& aReqStatus, TMobilePhonePrivacy& aSetting) const;

	/***********************************************************************************/
	//
	// TSY Capabilities for supplementary call services
	// 
	/***********************************************************************************/
	
/** The call services.

Modes: GSM/WCDMA */
	enum TMobilePhoneCallServiceCaps
		{
	/** Phone supports retrieval of call forwarding status from a cache on the phone.
	
	Modes: GSM/WCDMA */
		KCapsGetCFStatusCache				=0x00000001,
	/** Phone supports retrieval of call forwarding status from the network.
	
	Modes: GSM/WCDMA */
		KCapsGetCFStatusNetwork				=0x00000002,
	/** Phone supports setting of call forwarding status (and registered information) 
	in the network. */
		KCapsSetCFStatus					=0x00000004,
	/** Phone supports notification of change in status of any call forwarding service.
	
	Modes: GSM/WCDMA */
		KCapsNotifyCFStatus					=0x00000008,
	/** Phone supports retrieval of CLIP status from either a cache or the network.
	
	Modes: GSM/WCDMA */
		KCapsGetClipStatus					=0x00000010,
	/** Phone supports retrieval of CLIR status from either a cache or the network.
	
	Modes: GSM/WCDMA */
		KCapsGetClirStatus					=0x00000020,
	/** Phone supports retrieval of COLP status from either a cache or the network.
	
	Modes: GSM/WCDMA */
		KCapsGetColpStatus					=0x00000040,
	/** Phone supports retrieval of COLR status from either a cache or the network.
	
	Modes: GSM/WCDMA */
		KCapsGetColrStatus					=0x00000080,
	/** Phone supports retrieval of CNAP status from either a cache or the network.

	Modes: GSM/WCDMA */
		KCapsGetCnapStatus					=0x00000100,
	/** Phone supports retrieval of call barring status from a cache on the phone.
	
	Modes: Common */
		KCapsGetCBStatusCache				=0x00000200,
	/** Phone supports retrieval of call barring status from the network.
	
	Modes: GSM/WCDMA */
		KCapsGetCBStatusNetwork				=0x00000400,
	/** Phone supports setting of call barring status in the network.
	
	Modes: Common */
		KCapsSetCBStatus					=0x00000800,
	/** Phone supports notification of change in call barring status for any service.
	
	Modes: Common */
		KCapsNotifyCBStatus					=0x00001000,
	/** Phone supports setting of a password for call barring service.
	
	Modes: Common */
		KCapsChangeCBPassword				=0x00002000,
	/** Phone supports BAIC call barring service.
	
	Modes: Common */
		KCapsBarAllIncoming					=0x00004000,
	/** Phone supports BIC-Roam call barring service.
	
	Modes: Common */
		KCapsBarIncomingRoaming				=0x00008000,
	/** Phone supports BAOC call barring service.
	
	Modes: Common */
		KCapsBarAllOutgoing					=0x00010000,
	/** Phone supports BOIC call barring service.
	
	Modes: Common */
		KCapsBarOutgoingInternational		=0x00020000,
	/** Phone supports BOIC-ExHC call barring service.
	
	Modes: Common */
		KCapsBarOutgoingInternationalExHC	=0x00040000,
	/** Phone supports barring all cases at once.
	
	Modes: Common */
		KCapsBarAllCases					=0x00080000,
	/** Phone supports retrieval of call waiting status from a cache on the phone.
	
	Modes: GSM/WCDMA */
		KCapsGetCWStatusCache				=0x00100000,
	/** Phone supports retrieval of call waiting status from the network.
	
	Modes: GSM/WCDMA */
		KCapsGetCWStatusNetwork				=0x00200000,
	/** Phone supports setting of call waiting status in the network.
	
	Modes: Common */
		KCapsSetCWStatus					=0x00400000,
	/** Phone supports notification of change in call waiting status for any service.
	
	Modes: GSM/WCDMA */
		KCapsNotifyCWStatus					=0x00800000,
	/** Phone supports retrieval of call completion (CCBS) status from a cache on the 
	phone.
	
	Modes: GSM/WCDMA */
		KCapsGetCCBSStatusCache				=0x01000000,
	/** Phone supports retrieval of call completion (CCBS) status from the network.
	
	Modes: GSM/WCDMA */
		KCapsGetCCBSStatusNetwork			=0x02000000,
	/** Phone supports deactivation of all CCBS requests at once.
	
	Modes: GSM/WCDMA */
		KCapsDeactivateAllCCBS				=0x04000000,
		KCapsDeactivateCCBS					=0x08000000,
	/** Phone supports retrieval of a list of active CCBS requests.
	
	Modes: GSM/WCDMA */
		KCapsRetrieveActiveCCBS				=0x10000000,
	/** The phone supports programming and retrieval of feature code against a CDMA 
	network service.
	
	Modes: CDMA */
		KCapsFeatureCode					=0x20000000,
	/** The phone supports sending of generic network service request strings.
	
	Modes: Common */
		KCapsNetworkServiceRequest			=0x40000000,
	/** The phone supports retrieval of called line identification status.
	
	Modes: GSM/WCDMA */
		KCapsGetCdipStatus					=0x80000000
		};

	IMPORT_C TInt GetCallServiceCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyCallServiceCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

	/***********************************************************************************/
	//
	// MobilePhoneUserNetworkAccess functional unit
	//
	/***********************************************************************************/

/** Mobile Phone network services.

Modes: CDMA */
	enum TMobilePhoneNetworkService
		{
	/** Network service is unspecified. */
		ENetworkServiceUnspecified,
	/** Feature code applies to call forwarding unconditional service. */
		ECFUService,
	/** Feature code applies to call forwarding on busy service. */
		ECFBService,
	/** Feature code applies to call forwarding on no reply service. */
		ECFNRyService,
	/** Feature code applies to call forwarding on not reachable service. */
		ECFNRcService,
	/** Feature code applies to user selective call forwarding service - when the 
	user wishes to forward incoming call to voicemail. */
		EDeflectToVoicemail,
	/** Feature code applies to user selective call forwarding service - when the
	user wishes to forward incoming call to a number supplied within the deflect 
	request. */
		EDeflectToNumber,
	/** Feature code applies to user selective call forwarding service - when the 
	user wishes to forward incoming call to a number pre-registered within the 
	network. */
		EDeflectToRegisteredNumber,
	/** Feature code applies to call waiting service. */
		ECWService,
		ENextCallShowCLI,
	/** Feature code applies to caller ID restriction service - when user wishes to 
	hide their ID for the next call they make. */
		ENextCallHideCLI
		};

/** Mobile phone service actions.

Modes: Common */
	enum TMobilePhoneServiceAction
		{
	/** The action is unspecified. */
		EServiceActionUnspecified,
	/** The client is registering new service information. If the service was not active 
	then this action also activates the service. */
		EServiceActionRegister,
	/** The client is activating the service. */
		EServiceActionActivate,
	/** The client is invoking the service. */
		EServiceActionInvoke,
	/** The client is deactivating the service. */
		EServiceActionDeactivate,
	/** The client is erasing the currently registered service information. If the service 
	was active then this action also deactivates the service. */
		EServiceActionErase
		};
		
	/**
	Defines the type of SS operation
	*/
	enum TMobilePhoneNotifySendSSOperation
		{
		/**
		SS Invoke operation.
		*/
		ESendSSInvoke,
		/**
		SS ReturnResult operation.
		*/
		ESendSSReturnResult,
		/**
		SS ReturnError operation.
		*/
		ESendSSReturnError,
		/**
		SS Reject operation.
		*/
		ESendSSReject		
		};
	
	/** Size of additional info buffer. */	
	enum{ KAdditionalInfoSize = 244 };
	
	class TMobilePhoneSendSSRequestV3 : public TMultimodeType
	/**
	Contains the operation code and buffer to hold any additional information when receiving a notification 
	about a network service request.
	*/
		{
	public:
		IMPORT_C TMobilePhoneSendSSRequestV3();
	public:
		/**
		This is the Operation Code for a Send SS Invoke or Return result events.
		This is the Error or Problem Code for a Send SS Return Error or Reject events.
		*/
		TUint8	iOpCode;
		/**
		The additional information (parameters) for a Send SS Invoke or Return result or Return Error events.
		This is not used for a Send SS Reject event
		*/
		TBuf<KAdditionalInfoSize>	iAdditionalInfo;
		};
	
	/**
 	Packaging typedef for TMobilePhoneSendSSRequestV3 class.
 	*/	
	typedef TPckg<TMobilePhoneSendSSRequestV3> TMobilePhoneSendSSRequestV3Pckg;

	// API/TSY internal type

	struct TNetworkServiceAndAction
		{
		TMobilePhoneNetworkService iService;
		TMobilePhoneServiceAction iAction;
		};
	
	IMPORT_C void ProgramFeatureCode(TRequestStatus& aReqStatus, const TDesC& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const;
	IMPORT_C void GetFeatureCode(TRequestStatus& aReqStatus, TDes& aFCString, TMobilePhoneNetworkService aService, TMobilePhoneServiceAction aAction) const;

	IMPORT_C void SendNetworkServiceRequest(TRequestStatus& aReqStatus, const TDesC& aServiceString) const;
	IMPORT_C void SendNetworkServiceRequestNoFdnCheck(TRequestStatus& aReqStatus, const TDesC& aServiceString) const;
	IMPORT_C void NotifySendNetworkServiceRequest(TRequestStatus& aReqStatus, const TMobilePhoneNotifySendSSOperation aOperation, TDes8& aRequestComplete) const;

	/***********************************************************************************/
	//
	// MobilePhoneCallForwarding functional unit
	// 
	/***********************************************************************************/

/** The Call Forwarding flavours.

Modes: GSM/WCDMA */
	enum TMobilePhoneCFCondition
		{
	/** The call forwarding service is unspecified. */
		ECallForwardingUnspecified,
	/** All calls to this subscriber are forwarded. */
		ECallForwardingUnconditional,
	/** Calls are forwarded when this subscriber is busy. */
		ECallForwardingBusy,
	/** Calls are forwarded when this subscriber does not reply within a time-out period. */
		ECallForwardingNoReply,
	/** Calls are forwarded when this subscriber is unreachable. */
		ECallForwardingNotReachable,
	/** All of above CF services. Can be used to check all 4 call forwarding Fs 
	at once. */
		ECallForwardingAllCases,			// combination of all four above cases
	/** All the conditional (busy, no reply, not reachable) CF services. Can be used 
	to check all 3 conditional call forwarding conditions at once. */
		ECallForwardingAllConditionalCases	// combination of CFB, CFNRy and CFNRc
		};

/** The Call Forwarding status

Modes: GSM/WCDMA */
	enum TMobilePhoneCFStatus
		{
	/** The CF service is currently active and operative. */
		ECallForwardingStatusActive,
	/** The CF service is currently deactivated. */
		ECallForwardingStatusNotActive,
	/** The CF service is not registered. */
		ECallForwardingStatusNotRegistered,
	/** The CF service is not provisioned. */
		ECallForwardingStatusNotProvisioned,
	/** The CF service is not available in the serving network. */
		ECallForwardingStatusNotAvailable,
	/** The phone can not determine CF service status. */
		ECallForwardingStatusUnknown,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to allowed */
		ECallForwardingStatusActivePIAllowed,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to not available */
		ECallForwardingStatusActivePINotAvailable,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to restricted
	
	The Call Forwarding service is active and the presentation indicator is set 
	to restricted and screening returns "User provided, verified and passed". */
		ECallForwardingStatusActivePIClir,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to restricted and screening returns "User provided, not screened". */
		ECallForwardingStatusActivePIClirSIVerified,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to "restricted" and screening returns "Network provided". */
		ECallForwardingStatusActivePIClirSINotScreened,
	/** The Call Forwarding service is active and the presentation indicator is set 
	to "restricted" and screening returns "Network provided". */
		ECallForwardingStatusActivePIClirSINetwork,
	/** The CF service is currently in the quiescent state. */	
		ECallForwardingStatusQuiescent
		};
		
	

	class TMobilePhoneCFInfoEntryV1 : public TMultimodeType
/** Defines information about the call forwarding service.

Modes: GSM/WCDMA

@see CMobilePhoneCFList
@publishedPartner
@released 
*/
		{
	public:
		IMPORT_C TMobilePhoneCFInfoEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** The CF service of this list entry.
	
	@see TMobilePhoneCFCondition */
		TMobilePhoneCFCondition iCondition;
	/** The basic service group associated to this CF service list entry.
	
	@see TMobileService */
		TMobileService iServiceGroup;
	/** The current status of the call forwarding condition.
	
	@see TMobilePhoneCFStatus */
		TMobilePhoneCFStatus iStatus;
	/** The "forward-to" telephone number registered for the call forwarding condition. 
	An empty string if CF service is not registered, not provisioned or not available.
	
	@see TMobileAddress */
		TMobileAddress iNumber;
	/** The "No Reply" time-out (in seconds) registered for the call forwarding no reply 
	condition.
	
	Equals to -1 if this value is not applicable. In GSM mode, will be between 
	5 and 30 and in steps of 5 if this value is applicable. */
		TInt iTimeout; // valid for CFRNy only
		};

	IMPORT_C void NotifyCallForwardingStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCFCondition& aCondition) const;

	class TMobilePhoneCFChangeV1 : public TMultimodeType
/** Defines the call forward information.

@see SetCallForwardingStatus()
@publishedPartner
@released 
*/
		{
	public:
		IMPORT_C TMobilePhoneCFChangeV1();
	public:
	/** The basic service group(s) to apply the CF status change to.
	
	@see TMobileService */
		TMobileService iServiceGroup;
	/** The service action for call forwarding.
	
	@see TMobilePhoneServiceAction */
		TMobilePhoneServiceAction iAction;
	/** A new "forward-to" number to be registered against the CF condition. This is 
	applicable if iAction=EServiceActionRegister. In other cases, it is set to
	an empty string.
	
	@see TMobileAddress */
		TMobileAddress iNumber;
	/** The new "No Reply" time-out in seconds to be registered. This is applicable 
	if the CF condition is CFNRy and iAction=EServiceActionRegister. Equals -1 
	if this value is not applicable. If applicable, in GSM mode will be between 
	5 and 30 and in steps of 5. */
		TInt iTimeout;
		};

	IMPORT_C void SetCallForwardingStatus(TRequestStatus& aReqStatus, TMobilePhoneCFCondition aCondition, const TMobilePhoneCFChangeV1& aInfo) const;

/** Call Forwarding Active Notification

Modes: Common */
	enum TMobilePhoneCFActive
		{
	/** CF Unconditional is currently active. */
		ECFUnconditionalActive,
	/** CF Busy, CF No Reply or CF Not Reachable is currently active. */
		ECFConditionalActive
		};

	IMPORT_C void NotifyCallForwardingActive(TRequestStatus& aReqStatus, TMobileService& aServiceGroup, TMobilePhoneCFActive& aActiveType) const;
	
	/**
	Current status indicators for unconditional call forwarding.
	*/
	enum TCFUIndicatorStatus
		{
		/**
		CFU Indicator status unknown.
		*/
		KCFUIndicatorUnknown = 0x0,
		/**
		CFU Indicator status for Voice (TMobileServiceGroup EVoice).
		*/
		KCFUIndicatorVoice=0x01,
		/**
		CFU Indicator status for Fax (TMobileServiceGroup EFax).
		*/
		KCFUIndicatorFax=0x02,
		/**
		CFU Indicator status for Data Teleservices(TMobileServiceGroup EData).
		*/
		KCFUIndicatorData=0x04,
		/**
		CFU Indicator status for Sms (TMobileServiceGroup ESms).
		*/
		KCFUIndicatorSms=0x08,
		/**
		CFU Indicator status for Data Bearer Services(TMobileServiceGroup EDataBearer).
		*/
		KCFUIndicatorDataBearer=0x10
		};

	typedef TUint32 TCFUIndicatorStatusFlags;
		
	class TMobilePhoneCFUIndicatorV3 : public TMultimodeType
	/**
	Contains indicator parameters for unconditional call forwarding.
	*/
		{
	public:
		IMPORT_C TMobilePhoneCFUIndicatorV3();
	public:
		/**
		Current setting for indicator status.
		Can contain a number of flags from RMobilePhone::TCFUIndicatorStatus.
		*/
		TCFUIndicatorStatusFlags iIndicator;		
		};
		
	typedef TPckg<TMobilePhoneCFUIndicatorV3> TMobilePhoneCFUIndicatorV3Pckg;

	/**
	The MSP number contains the Profile Identity of the subscriber profile.
	The Profile Identity shall be any of the following enlisted.
	@see 3GPP TS 31.102 v7.4.1 section 4.2.64
	@see 3GPP TS 23.097 [36]
	*/
	enum TMultipleSubscriberProfileID
		{
		/**
		Profile Identity Unknown
		*/
		KProfileIdentityUnknown = 0x0,
		/**
		Profile Identity 1
		*/
		KProfileIdentityOne = 0x01,
		/**
		Profile Identity 2
		*/
		KProfileIdentityTwo = 0x02,
		/**
		Profile Identity 3
		*/
		KProfileIdentityThree = 0x04,
		/**
		Profile Identity 4
		*/
		KProfileIdentityFour = 0x08
		};

	class TMobilePhoneCFUIndicatorV6 : public TMobilePhoneCFUIndicatorV3
	/**
	Contains the indicator parameters for unconditional call forwarding.
	The TMobilePhoneCFUIndicatorV6 supports MSP number(Multiple Subscriber Profile) and Call Forwarding Number.
	Upto four different profiles can be provisioned against a subscriber using the MSP feature.
	@see 3GPP TS 31.102 v7.4.1 section 4.2.64
	*/
		{
	public:
		IMPORT_C TMobilePhoneCFUIndicatorV6();
	public:
		/**
		@see RMoblie::TMobileAddress
		*/
		TMobileAddress iCFNumber;
		/**
		The profile IDs allow unambiguous identification of each profile. 
		This will allow the subscriber to select the preferred profile for outgoing calls and for subscriber actions. 
		For terminating calls the profile ID shall be part of the notification of the profile.
		*/
		TMultipleSubscriberProfileID iMultipleSubscriberProfileID;
		};

	typedef TPckg<TMobilePhoneCFUIndicatorV6> TMobilePhoneCFUIndicatorV6Pckg;

	IMPORT_C void GetCallForwardingIndicator(TRequestStatus& aReqStatus, TDes8& aIndicator) const;

	/***********************************************************************************/
	//
	// Mobile Identity Service functional unit
	// 
	/***********************************************************************************/

/** Phone ID services (CLIP/CNIP/CLIR).

Modes: GSM/WCDMA */
	enum TMobilePhoneIdService
		{
	/** The identity service is unspecified */
		EIdServiceUnspecified,
	/** The caller's ID is presented to the called party. */
		EIdServiceCallerPresentation,
	/** The caller's ID is restricted to the called party. */
		EIdServiceCallerRestriction,
	/** The connected party's ID is presented to the calling party. */
		EIdServiceConnectedPresentation,
	/** The connected party's ID is restricted to the calling party. */
		EIdServiceConnectedRestriction,
	/** The caller's name is presented to the called party. */
		EIdServiceCallerName,
	/** The called party is presented with the caller's ID. This command enables a 
	called subscriber to get the called line identification of the called party 
	when receiving a mobile terminated call. - maps to +CDIP. */
		EIdServiceCalledPresentation
		};

/** Service status of the Phone ID services (CLIP/CLIR/CNIP).

Modes: GSM/WCDMA */
	enum TMobilePhoneIdServiceStatus
		{
	/** The interrogated Identity service is provisioned and active. This status is 
	used for all identity services and in the case of the CLIR service means that 
	it is permanently active with no subscription option set. */
		EIdServiceActivePermanent,
	/** This status is used for the CLIR service only and means that the service is 
	provisioned and active.
	
	The CLIR subscription option is set to "Temporary, default restricted", therefore 
	identity is always restricted unless over-ridden by the user during a call 
	set-up. */
		EIdServiceActiveDefaultRestricted,
	/** This status is used for the CLIR service only and means that the service is 
	provisioned and active.
	
	The CLIR subscription option is set to "Temporary, default allowed", therefore 
	identity is always allowed unless over-ridden by the user during a call set-up. */
		EIdServiceActiveDefaultAllowed,
	/** The interrogated Identity service is not provisioned. */
		EIdServiceNotProvisioned,
	/** The status of the interrogated Identity service is unknown. */
		EIdServiceUnknown
		};

	// for use by client-side API code and TSY only

	struct TIdServiceAndLocation
		{
		TMobilePhoneIdService iService;
		TMobileInfoLocation iLocation;
		};

	/** This function member retrieves the current status of the identity service specified.
	
	The phone will retrieve this service status information from the location 
	specified by the client.
	
	If the client has requested EInfoLocationCache but there is no valid status 
	information in the cache then the request will return KErrNotFound.
	
	If the client has requested EInfoLocationCachePreferred, the network will 
	be interrogated if the cache is empty. Whenever the network is interrogated, 
	the cache will be refreshed with the information from the network.
	
	Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneGetIdentityServiceStatus) 
	to cancel a previously placed asynchronous GetIdentityServiceStatus() request.
	
	@param aReqStatus On return, KErrNone if successful.
	@param aService The identity service to be queried.
	@param aStatus On return, the service status.
	@param aLocation The location to use. */
	IMPORT_C void GetIdentityServiceStatus(TRequestStatus& aReqStatus, TMobilePhoneIdService aService, TMobilePhoneIdServiceStatus& aStatus, TMobileInfoLocation aLocation = EInfoLocationCachePreferred) const;
	
	/**
	Identifies default service status for provisioned identity services.
	*/
	enum TMobilePhoneIdServiceSetting
		{
		/** Sets the default setting to network default (unknown). */
		EIdServiceNetworkDefault,
		/** Sets the default setting to presentation restricted. */
		EIdServicePresentationRestricted,
		/** Sets the default setting to presentation allowed. */
		EIdServicePresentationAllowed
		};
		
	IMPORT_C void SetIdentityServiceStatus(TRequestStatus& aReqStatus, const TMobilePhoneIdService aService, const TMobilePhoneIdServiceSetting aSetting) const;
	IMPORT_C void NotifyIdentityServiceStatus(TRequestStatus& aReqStatus, const TMobilePhoneIdService aService, TMobilePhoneIdServiceStatus& aStatus) const;
	IMPORT_C void NotifyIdentitySuppressionRejected(TRequestStatus& aReqStatus) const;

	/***********************************************************************************/
	//
	// Mobile Call Barring Functional Unit
	//
	/***********************************************************************************/

/** Mobile Phone Call Baring Conditions.

Modes: Common */
	enum TMobilePhoneCBCondition
		{
	/** The barring program is unspecified */
		EBarUnspecified,
	/** All incoming calls to this subscriber are barred (BAIC). */
		EBarAllIncoming,
	/** All incoming calls to this subscriber are barred when roaming outside the home 
	PLMN country (BIC-roam). */
		EBarIncomingRoaming,
	/** All outgoing calls by this subscriber are barred (BAOC). */
		EBarAllOutgoing,
	/** All outgoing international calls by this subscriber are barred (BOIC). */
		EBarOutgoingInternational,
	/** All outgoing international calls except those directed to the home PLMN country 
	by this subscriber are barred (BOIC-ExHC). */
		EBarOutgoingInternationalExHC,
	/** All of above CB services. */
		EBarAllCases,
		EBarAllOutgoingServices,
		EBarAllIncomingServices
		};

/** Mobile Phone Call Barring Status and Information.

Modes: Common */
	enum TMobilePhoneCBStatus
		{
	/** The CB service is currently active and operative. */
		ECallBarringStatusActive,
	/** The CB service is currently deactivated or quiescent. */
		ECallBarringStatusNotActive,
	/** In GSM/WCDMA mode, the CB service is not provisioned. In CDMA mode, this value 
	has no meaning. */
		ECallBarringStatusNotProvisioned,
	/** In GSM/WCDMA mode, the CB service is not available in serving network. In CDMA
	mode, the CB service is not available in the phone. */
		ECallBarringStatusNotAvailable,
	/** The phone can not determine CB service status. */
		ECallBarringStatusUnknown
		};

	

	class TMobilePhoneCBInfoEntryV1 : public TMultimodeType
/** Defines information about the call barring service.

@see CMobilePhoneCBList
@publishedPartner
@released 
*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobilePhoneCBInfoEntryV1();
	public:
	/** The CB service of this list entry.
	
	Modes: Common
	
	@see TMobilePhoneCBCondition */
		TMobilePhoneCBCondition iCondition;
	/** The service group associated to this list entry.
	
	Modes: Common
	
	@see TMobileService */
		TMobileService iServiceGroup;
	/** The CB service status of this list entry.
	
	Modes: Common
	
	@see TMobilePhoneCBStatus */
		TMobilePhoneCBStatus iStatus;
		};
		
	class TMobilePhoneCBInfoEntryV3 : public TMobilePhoneCBInfoEntryV1
	/**
	V3 class extending TMobilePhoneCBInfoEntryV1 to add a comparison method parameter.
	*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobilePhoneCBInfoEntryV3();
	public:
		/**
		The comparison method associated with this CB entry.
		*/
		TUint8 iCompMethod;
		};
		
	class TMobilePhoneCBChangeV1 : public TMultimodeType
/** Mobile Phone Call Barring Change.

@see SetCallBarringStatus() 
*/
		{
	public:
		IMPORT_C TMobilePhoneCBChangeV1();
	public:
	/** The basic service group(s) to apply the CB status change to.
	
	@see TMobileService */
		TMobileService iServiceGroup;
	/** The service action for call barring.
	
	@see TMobilePhoneServiceAction */
		TMobilePhoneServiceAction iAction;
	/** Password required to perform the call barring service action.
	
	@see TMobilePassword */
		TMobilePassword iPassword;
		};

	IMPORT_C void SetCallBarringStatus(TRequestStatus& aReqStatus, TMobilePhoneCBCondition aCondition, const TMobilePhoneCBChangeV1& aInfo) const;
	IMPORT_C void NotifyCallBarringStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCBCondition& aCondition) const;
	
	class TMobilePhonePasswordChangeV1 : public TMultimodeType
/** Mobile phone password change.

@see SetCallBarringPassword()
@see ChangeSecurityCode()
@publishedPartner
@released 
*/
		{
	public:
		IMPORT_C TMobilePhonePasswordChangeV1();
	public:
	/** Old password.
	
	Modes: Common
	
	@see TMobilePassword */
		TMobilePassword iOldPassword;
	/** New password.
	
	Modes: Common
	
	@see TMobilePassword */
		TMobilePassword iNewPassword;
		};

	IMPORT_C void SetCallBarringPassword(TRequestStatus& aReqStatus, const TMobilePhonePasswordChangeV1& aPassword) const;

	class TMobilePhonePasswordChangeV2 : public TMobilePhonePasswordChangeV1
/** Mobile phone password change version 2. 
*/
	{
	public:
		IMPORT_C TMobilePhonePasswordChangeV2();
	public:
	/** Verified password.
	
	Modes: Common
	
	@see TMobilePassword */
		TMobilePassword iVerifiedPassword;
	};

/** A typedef'd packaged TMobilePhonePasswordChangeV2 passing through a generic 
API function member. */
	typedef TPckg<TMobilePhonePasswordChangeV2> TMobilePhonePasswordChangeV2Pckg;

	IMPORT_C void SetSSPassword(TRequestStatus& aReqStatus, const TDesC8& aPassword, const TInt aService) const;
	
	IMPORT_C void GetCompMethodName(TRequestStatus& aReqStatus, TDes& aAlphaTag, const TUint8 aCmi) const;

	/***********************************************************************************/
	//
	// Mobile Call Waiting Functional Unit
	//
	/***********************************************************************************/

/** The mobile phone call waiting status.

Modes: GSM/WCDMA */
	enum TMobilePhoneCWStatus
		{
	/** The CW service is currently active and operative. */
		ECallWaitingStatusActive,
	/** The CW service is currently deactivated or quiescent. */
		ECallWaitingStatusNotActive,
	/** The CW service is not provisioned. */
		ECallWaitingStatusNotProvisioned,
	/** The CW service is not available in the serving network. */
		ECallWaitingStatusNotAvailable,
	/** The phone can not determine CW service status. */
		ECallWaitingStatusUnknown
		};

	

	class TMobilePhoneCWInfoEntryV1 : public TMultimodeType
/** Defines information about the call waiting service.

@see CMobilePhoneCWList 
*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobilePhoneCWInfoEntryV1();
	public:
	/** The service group associated to this CW service list entry.
	
	Modes: GSM/WCDMA
	
	@see TMobileService */
		TMobileService iServiceGroup;
	/** The CW service status of this list entry.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneCWStatus */
		TMobilePhoneCWStatus iStatus;
		};

/** A typedef'd packaged TMobilePhoneCWInfoEntryV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneCWInfoEntryV1> TMobilePhoneCWInfoEntryV1Pckg;

	IMPORT_C void SetCallWaitingStatus(TRequestStatus& aReqStatus, TMobileService aServiceGroup, TMobilePhoneServiceAction aAction) const;
	IMPORT_C void NotifyCallWaitingStatusChange(TRequestStatus& aReqStatus, TDes8& aCWStatus) const;

	/***********************************************************************************/
	//
	// Mobile Call Completion Unit
	//
	/***********************************************************************************/

/** The Call Completion Busy Subscriber status of the phone.

Modes: GSM/WCDMA */
	enum TMobilePhoneCCBSStatus
		{
	/** User has CCBS provisioned and there is at least 1 (and up to 5) active CCBS 
	requests. */
		ECcbsActive,
	/** User has CCBS provisioned but there are currently no active CCBS requests. */
		ECcbsNotActive,
	/** User has not subscribed to the CCBS service. */
		ECcbsNotProvisioned,
	/** The CCBS service is not available in the serving network. */
		ECcbsNotAvailable,
	/** MS is unable to determine status of the CCBS service. */
		ECcbsUnknown
		};

/** CCBS recall events.

@see RMobilePhone::TMobilePhoneCCBSEntryV2 */
	enum TCCBSRecallEvent
		{
	/** Recall received. */
		ECcbsRecallReceived,
	/** Recall accepted. */
		ECcbsRecallAccepted,
	/** Recall refused. */
		ECcbsRecallRefused,
	/** Recall reason unspecified. */
		ECcbsRecallUnspecified
		};

	

	class TMobilePhoneCCBSEntryV1 : public TMultimodeType
/** Defines information about the call completion (CCBS) service.

@see CMobilePhoneCcbsList
@publishedPartner
@released 
*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobilePhoneCCBSEntryV1();
	public:
	/** The CCBS index - a number allocated by the network.
	
	Modes: GSM/WCDMA */
		TInt			iCcbsIndex;
	/** The basic service group (voice/data/fax) this CCBS request is applicable to.
	
	Modes: GSM/WCDMA
	
	@see TMobileService */
		TMobileService	iServiceGroup;
	/** The phone number of the remote party to whom the CCBS request is aimed.
	
	Modes: GSM/WCDMA
	
	@see TMobileAddress */
		TMobileAddress	iDestination;

		};

/** A typedef'd packaged TMobilePhoneCCBSEntryV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneCCBSEntryV1> TMobilePhoneCCBSEntryV1Pckg;


	class TMobilePhoneCCBSEntryV2 : public TMobilePhoneCCBSEntryV1
/** Defines information about the call completion (CCBS) service version 2. 
*/
		{
	public:
		IMPORT_C	TMobilePhoneCCBSEntryV2();
	public:
		TCCBSRecallEvent	iEvent;
		}; 
	
/** A typedef'd packaged TMobilePhoneCCBSEntryV2 for passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneCCBSEntryV2> TMobilePhoneCCBSEntryV2Pckg;
	
	IMPORT_C void GetCCBSStatus(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus, TMobileInfoLocation aLocation = EInfoLocationCachePreferred) const;
	IMPORT_C void NotifyCCBSStatusChange(TRequestStatus& aReqStatus, TMobilePhoneCCBSStatus& aCcbsStatus) const;
	IMPORT_C void DeactivateCCBS(TRequestStatus& aReqStatus, TInt aIndex) const;
	IMPORT_C void NotifyCCBSRecall(TRequestStatus& aReqStatus, TDes8& aCCBSEntry) const;
	IMPORT_C void AcceptCCBSRecall(TRequestStatus& aReqStatus, TInt aIndex, TName& aCallName) const;
	IMPORT_C TInt RefuseCCBSRecall(TInt aIndex) const;

	/***********************************************************************************/
	//
	// Mobile Alternating Call Function Unit
	//
	/***********************************************************************************/

/** Alternating Call Capabilities

Modes: GSM */
	enum TMobilePhoneAlternatingCallCaps
		{
	/** Phone supports outgoing Voice/Data calls
	
	Modes: GSM */
		KCapsMOVoiceData = 0x00000001,
	/** Phone supports outgoing Voice Then Data calls.
	
	Modes: GSM */
		KCapsMOVoiceThenData = 0x00000002,
	/** Phone supports outgoing Voice/Fax calls.
	
	Modes: GSM/WCDMA */
		KCapsMOVoiceFax	= 0x00000004,
	/** Phone supports incoming Voice/Data calls.
	
	Modes: GSM */
		KCapsMTVoiceData = 0x00000008,
	/** Phone supports incoming Voice Then Data calls.
	
	Modes: GSM */
		KCapsMTVoiceThenData = 0x00000010,
	/** Phone supports incoming Voice/Fax calls

	Modes: GSM/WCDMA */
		KCapsMTVoiceFax = 0x00000020
		};

	IMPORT_C TInt GetAlternatingCallCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyAlternatingCallCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

/** Alternating Call Mode.

Modes: Common */
	enum TMobilePhoneAlternatingCallMode
		{
	/** The alternating call mode is unspecified
	
	Modes: Common */
		EAlternatingModeUnspecified,
	/** Next call will use a single bearer service - default setting
	
	Modes: Common */
		EAlternatingModeSingle,
	/** Next call will use voice/data alternating bearer service. 
	
	Modes: GSM */
		EAlternatingModeVoiceData,
	/** Next call will use voice then data alternating bearer service.
	
	Modes: GSM */
		EAlternatingModeVoiceThenData,
	/** Next call will use voice/fax alternating bearer service. 
	
	Modes: GSM/WCDMA */
		EAlternatingModeVoiceFax
		};

	IMPORT_C TInt GetAlternatingCallMode(TMobilePhoneAlternatingCallMode& aMode, TMobileService& aFirstService) const;
	IMPORT_C void SetAlternatingCallMode(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode aMode, TMobileService aFirstService) const;
	IMPORT_C void NotifyAlternatingCallModeChange(TRequestStatus& aReqStatus, TMobilePhoneAlternatingCallMode& aMode,TMobileService& aFirstService) const;

	/***********************************************************************************/
	//
	// Mobile Alternate Line Service Functional Unit
	//
	/***********************************************************************************/

/** Alternate Line Primary settings.

Modes: GSM */
	enum TMobilePhoneALSLine
		{
	/** Current ALS line selection is the "Primary" voice line. */
		EAlternateLinePrimary,
	/** Current ALS line selection is the "Auxiliary" voice line. */
		EAlternateLineAuxiliary,
	/** ALS is supported by ME and SIM, but the TSY can not determine which line is 
	currently selected. */
		EAlternateLineUnknown,
	/** The ME, SIM or serving network does not support ALS. */
		EAlternateLineNotAvailable
		};

	IMPORT_C TInt GetALSLine(TMobilePhoneALSLine& aALSLine) const;
	IMPORT_C void SetALSLine(TRequestStatus& aReqStatus, TMobilePhoneALSLine aALSLine) const;
	IMPORT_C void NotifyALSLineChange(TRequestStatus& aReqStatus, TMobilePhoneALSLine& aALSLine) const;

	/***********************************************************************************/	
	//
	// Mobile Network Security Functional Unit
	//
	/***********************************************************************************/

/** Enumerated network security types.

Mode: Common */
	enum TMobilePhoneNetworkSecurity
		{
	/** The encryption level is NONE.
	
	Mode: Common */
		ECipheringOff,
	/** The encryption level is GSM.(standard encryption algorithms for 2nd Generation 
	Mobile networks).
	
	Mode: GSM */
		ECipheringGSM,
	/** The encryption level is WCDMA.(standard encryption algorithms for 3rd Generation 
	Mobile networks).
	
	Mode: WCDMA */
		ECipheringWCDMA,
	/** The encryption level is CDMA.(standard encryption algorithms for 3rd Generation 
	Mobile networks).
	
	Mode: CDMA */
		ECipheringCDMA
		};

	IMPORT_C void GetNetworkSecurityLevel(TRequestStatus& aReqStatus, TMobilePhoneNetworkSecurity& aSecurity) const;
	IMPORT_C void NotifyNetworkSecurityLevelChange(TRequestStatus& aReqStatus, TMobilePhoneNetworkSecurity& aSecurity) const;
	
	/**
	Indicators for whether encryption status of the current call should be displayed.
	*/
	enum TMobileCallCipheringIndicator
		{
		/**
		The ME indication displaying the encryption status of the current call should be off.
		*/
		ECipheringDisplayOff,
		/**
		The ME indication displaying the encryption status of the current call should be on.
		*/
		ECipheringDisplayOn 
		};
		
    IMPORT_C void GetCipheringIndicatorStatus(TRequestStatus& aReqStatus, TMobileCallCipheringIndicator& aIndicatorStatus) const;
    IMPORT_C void NotifyCipheringIndicatorStatus(TRequestStatus& aReqStatus, TMobileCallCipheringIndicator& aIndicatorStatus) const;

	/***********************************************************************************/
	//
	// Mobile Cost Functional Unit
	//
	/***********************************************************************************/

/** Call Cost Capabilities.

Modes: GSM/WCDMA */
	enum TMobilePhoneCostCaps
		{
	/** Indicates that the phone supports calculation and display of current and accumulated 
	call cost on an information-only basis. (The AoCI service in GSM) 
	
	Modes: GSM/WCDMA */
		KCapsCostInformation = 0x00000001,
	/** Indicates that the phone supports calculation and display of current and accumulated 
	call cost in order to support the charging service. (The AoCC service in GSM). 


	Modes: Common */
		KCapsCostCharging = 0x00000002,
	/** Indicates that the phone supports clearing of cost meters (ACM or CCM) to zero.
	
	Modes: Common */
		KCapsClearCost = 0x00000004,
	/** Indicates that the phone supports setting the maximum allowed cost (ACMmax) 
	to a non-zero value. 
	
	Modes: Common */
		KCapsSetMaxCost = 0x00000008,
	/** Indicates that the phone supports setting the currency and price per unit.
	
	Modes: GSM/WCDMA */
		KCapsSetPuct = 0x00000010,
	/** Indicates that the phone currently has call cost information available that 
	the client can retrieve.
	
	Modes: Common */
		KCapsGetCost = 0x00000020,
	/** Indicates that the phone can notify the client when the call cost information 
	changes. 
	
	Modes: Common */
		KCapsNotifyCostChange = 0x00000040
		};

	IMPORT_C TInt GetCostCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyCostCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

/** Clear Cost Meter.

Modes: Common */
	enum TMobilePhoneCostMeters
		{
	/** Clear the Current Call Meter. */
		EClearCCM,
	/** Clear the Accumulated Charge Meter. */
		EClearACM,
	/** Clear all cost meters */
		EClearAll
		};

	IMPORT_C void ClearCostMeter(TRequestStatus& aReqStatus, TMobilePhoneCostMeters aMeter) const;
	IMPORT_C void SetMaxCostMeter(TRequestStatus& aReqStatus, TUint aUnits) const;

	
	
	class  TMobilePhonePuctV1 : public TMultimodeType
/** Defines the contents of the price/unit and currency table (PUCT) on the SIM.

@see TMobilePhoneCostInfoV1
@see SetPuct() 
*/
		{
	public:
		IMPORT_C TMobilePhonePuctV1();
	public:
	/** The Price per Unit. This floating point value is used to adjust the pricing 
	units supplied by the network into real currency values. 
	
	Modes: GSM/WCDMA */
		TReal   iPricePerUnit;
	/** The three character currency indicator.
	
	Modes: GSM/WCDMA */
		TBuf<4> iCurrencyName;
		};

/** A typedef'd packaged TMobilePhonePuctV1 for passing through a generic API function 
member. */
	typedef TPckg<TMobilePhonePuctV1> TMobilePhonePuctV1Pckg;
	
	IMPORT_C void SetPuct(TRequestStatus& aReqStatus, const TDesC8& aPuct) const;
	
/** Cost Information

Modes: GSM/WCDMA */
	enum TMobilePhoneCostService
		{
	/** Phone supports call cost service but no calls are currently in progress so the 
	network support and user subscription is unknown. */
		ECostServiceUnknown,
	/** The network or the phone does not support any of the call cost services. The 
	call can be either in progress or not. If the user is subscribed to AoCI they 
	will be able to continue to make calls but will not see any charging information. 
	If the user is subscribed to AoCC then they will be prevented from making 
	chargeable calls. */
		ECostServiceNotAvailable,
	/** Call is in progress and a call cost service is active but the phone is unable 
	to determine whether it is an AoCI or AoCC service. */
		ECostServiceAvailable,
	/** Call is in progress and the call cost information (AoCI) service is currently 
	operating.
	
	Modes: GSM/WCDMA */
		ECostServiceInformation,
	/** Call is in progress and the call cost charging (AoCC) service is currently operating.
	
	Modes: GSM/WCDMA */
		ECostServiceCharging
		};

	

	class TMobilePhoneCostInfoV1 : public TMultimodeType
/** Defines the information related to current billing costs.

@see GetCostInfo()
@see NotifyCostInfoChange() 
*/
		{
	public:
		IMPORT_C TMobilePhoneCostInfoV1();
	public:
	/** The current status and type of call cost service.
	
	@see TMobilePhoneCostService */
		TMobilePhoneCostService iService;
	/** The current number of charging units in the Current Call Meter. This is set 
	to zero if reset by the user or at the start of call set-up attempt. */
		TUint iCCM;
	/** The current number of charging units in the Accumulated Call Meter. This equals 
	the accumulation of previous and current calls. */
		TUint iACM;
	/** The maximum number of charging units that the ACM can rise to before chargeable 
	calls are stopped. Equals zero if Service != ECostServiceCharging. */
		TUint iACMmax;
	/** The Price per Unit and Currency Table.
	
	@see TMobilePhonePuctV1 */
		TMobilePhonePuctV1 iPuct;
		};

/** A typedef'd packaged TMobilePhoneCostInfoV1 for passing through a generic API
function member. */
	typedef TPckg<TMobilePhoneCostInfoV1> TMobilePhoneCostInfoV1Pckg;

	IMPORT_C void GetCostInfo(TRequestStatus& aReqStatus, TDes8& aCostInfo) const;
	IMPORT_C void NotifyCostInfoChange(TRequestStatus& aReqStatus, TDes8& aCostInfo) const;

	/***********************************************************************************/
	//
	// Mobile Security Functional Unit
	//
	/***********************************************************************************/

/** Security Capabilities.

Modes: Common */
	enum TMobilePhoneSecurityCaps
		{
	/** The phone supports an overall "phone device lock" which can be enabled or disabled. 
	If enabled, user must enter phone password before the phone can be used. When 
	this capability is set the phone will support get lock info, notify lock info 
	change and set lock setting for phone device lock.
	
	Modes: Common */
		KCapsLockPhone = 0x0000001,
	/** The phone supports locking the ICC (using the PIN1 security code), which can 
	be enabled or disabled. If enabled, the user must enter PIN1 code before the 
	ICC can be used. When this capability is set the phone will support get lock 
	info, notify lock info change and set lock setting for ICC lock. 
	
	Modes: Common */
		KCapsLockICC = 0x00000002,
	/** The phone supports the "phone to ICC lock" which can be enabled or disabled. 
	If enabled, at power-up the phone will check whether current ICC is the one 
	the phone is locked to or not. If not, then the user must enter the phone
	password before phone can be used with this ICC. When this capability is set 
	the phone will support get lock info, notify lock info change and set lock 
	setting for Phone-ICC lock. 
	
	Modes: Common */
		KCapsLockPhoneToICC = 0x00000004,
	/** The phone supports the "phone to first ICC lock" which can be enabled or disabled. 
	If enabled, at power-up the phone will check whether current ICC is the one 
	the phone is first locked to or not. If not, then user must enter the phone 
	password before the phone can be used with this ICC. When this capability 
	is set the phone will support get lock info, notify lock info change and set 
	lock setting for Phone-First ICC lock.

	Modes: Common */
		KCapsLockPhoneToFirstICC = 0x00000008,
	/** The phone supports the "Over The Air" programming lock which can be enabled 
	or disabled. If enabled, the phone will prevent OTA programming by the network. 
	If disabled, the phone will allow OTA programming by the network. When this 
	capability is set the phone will support get lock info, notify lock info change 
	and set lock setting for OTA lock. 
	
	Modes: CDMA */
		KCapsLockOTA = 0x00000010,
	/** The phone supports access to the PIN 1 security code. When this capability is 
	set the phone will support verification of PIN1, unblocking PIN1, changing 
	PIN1 and notification of PIN1 required. 
	
	Modes: Common */
		KCapsAccessPin1 = 0x00000020,
	/** The phone supports access to the PIN 2 security code. When this capability is 
	set the phone will support verification of PIN2, unblocking PIN2, changing 
	PIN2 and notification of PIN2 required.
	
	Modes: GSM/WCDMA */
		KCapsAccessPin2 = 0x00000040,
	/** The phone supports access to the phone password security code. When this capability 
	is set the phone will support verification of the phone password, changing 
	the phone password and notification if the phone password is required. 
	
	Modes: Common */
		KCapsAccessPhonePassword = 0x00000080,
	/** The phone supports access to the SPC (Service Programming Code) security code. 
	This code may need to be verified before OTA can commence.
	
	Modes: CDMA */
		KCapsAccessSPC = 0x00000100,
	/** The phone supports access to the hidden key. When this capability is set the
	phone will support verification of HiddenKey. 
	
	Modes: WCDMA */
		KCapsAccessHiddenKey=0x00000200,
	/** The phone supports access to the USIM Application PIN. An Application PIN allows 
	access to any file on the UICC where it is referenced in the access rules.
	
	Modes: WCDMA */
		KCapsAccessUSIMAppPin=0x00000400,
	/** The phone supports access to the second USIM Application PIN. The second Application 
	PIN allows access to files (where it is referenced in the access rules) within 
	one USIM Application on the UICC. This is a local PIN.
	
	Modes: WCDMA */
		KCapsAccessUSIMAppSecondPin =0x00000800,
	/** The phone supports access to the Universal PIN. A Universal PIN is a PIN that 
	is used in a multi-application UICC environment to allow several USIM applications 
	to share one common PIN.
	
	Modes: WCDMA */
		KCapsAccessUniversalPin =0x00001000
		};

	IMPORT_C TInt GetSecurityCaps(TUint32& aCaps) const;
	IMPORT_C void NotifySecurityCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

/** Lock Information.

Modes: Common */
	enum TMobilePhoneLock
		{
	/** Lock the whole device. Phone lock password is required to unlock when this lock 
	is enabled. 

	Modes: Common */
		ELockPhoneDevice,
	/** Lock PIN1 on the ICC. PIN1 security code is required to unlock when this lock 
	is enabled. 
	
	Modes: Common */
		ELockICC,
	/** Lock the phone to the current ICC inserted in the phone Phone lock password 
	is required to unlock when this lock is enabled.
	
	Modes: Common */
		ELockPhoneToICC,
	/** Lock the phone to the first ICC inserted in the phone. Phone lock password is 
	required to unlock when this lock is enabled.
	
	Modes: Common */
		ELockPhoneToFirstICC,
	/** Lock the OTA facility on the phone. SPC security code may be required to unlock 
	when this lock is enabled.
	
	Modes: CDMA */
		ELockOTA,
	/** Lock PIN2 on the ICC. PIN2 security code is required to unlock when this lock 
	is enabled.
	
	Modes: Common */
		ELockPin2,
	/** Lock the phonebook hidden entries on the phone. Hidden key security code may 
	be required to unlock when this lock is enabled.
	
	Modes: WCDMA */
		ELockHiddenKey,
	/** Lock the associated USIM Application. USIM Application PIN is required to unlock 
	when this lock is enabled.
	
	Modes: WCDMA */
		ELockUSimApp,
	/** Lock the associated USIM Application. The second USIM Application PIN is required 
	to unlock when this lock is enabled.
	
	Modes: WCDMA */
		ELockSecondUSimApp,
	/** Lock the associated USIM Application(s) that share this common lock. Universal 
	Pin is required to unlock when this lock is enabled.
	
	Modes: WCDMA */
		ELockUniversalPin,
	/** Lock for the NAM.  The SPC is required to unlock.
	
	Modes: CDMA */
		ELockNam
		};

/** Phone lock status.

Modes: Common */
	enum TMobilePhoneLockStatus
		{
	/** The status of the lock is unknown. */
		EStatusLockUnknown,
	/** Lock is closed - user can not access functionality governed by this lock until 
	user correctly enters associated security code. */
		EStatusLocked,
	/** Lock is open - user can access functionality governed by this lock */
		EStatusUnlocked,
		EStatusBlocked
		};

/** The phone lock setting.

Modes: Common */
	enum TMobilePhoneLockSetting
		{
	/** The setting of the lock is unknown
	
	Modes: Common */
		ELockSetUnknown,
	/** Lock is enabled - associated security code will be required to unlock the 
	lock, the next time the lock's status is EStatusLocked. 
	
	Modes: Common */
		ELockSetEnabled,
	/** Lock is disabled - so its status is always EStatusUnlocked.
	
	Modes: Common */
		ELockSetDisabled,
	/** Lock of the current Application is replaced by the Universal PIN. Only the 
	Universal PIN is allowed as a replacement.

	Modes: WCDMA */
		ELockReplaced
		};

	

	class TMobilePhoneLockInfoV1 : public TMultimodeType
/** Defines the status of a phone lock.

@see GetLockInfo()
@see NotifyLockInfoChange()
@publishedPartner
@released
*/
		{
	public:
		IMPORT_C TMobilePhoneLockInfoV1();
	public:
	/** The current status of the lock.
	
	Modes: Common
	
	@see TMobilePhoneLockStatus */
		TMobilePhoneLockStatus iStatus;
	/** The current setting of the lock.
	
	Modes: Common
	
	@see TMobilePhoneLockSetting */
		TMobilePhoneLockSetting iSetting;
		};

/** A typedef'd packaged TMobilePhoneLockInfoV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobilePhoneLockInfoV1> TMobilePhoneLockInfoV1Pckg;

	IMPORT_C void GetLockInfo(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TDes8& aLockInfo) const;
	IMPORT_C void NotifyLockInfoChange(TRequestStatus& aReqStatus, TMobilePhoneLock& aLock, TDes8& aLockInfo) const;
	IMPORT_C void SetLockSetting(TRequestStatus& aReqStatus, TMobilePhoneLock aLock, TMobilePhoneLockSetting aSetting) const;

/** Change Security Code.

Modes: Common */
	enum TMobilePhoneSecurityCode
		{
	/** PIN 1 code (between 4-8 digits).

	Modes: Common */
		ESecurityCodePin1,
	/** PIN 2 code (between 4-8 digits)
	
	Modes: GSM/WCDMA */
		ESecurityCodePin2,
	/** PIN 1 unblocking code (always 8 digits).
	
	Modes: Common */
		ESecurityCodePuk1,
	/** PIN 2 unblocking code (always 8 digits)
	
	Modes: GSM/WCDMA */
		ESecurityCodePuk2,
	/** Password used for Phone-SIM Lock and Phone Device Lock (up to 8 digits) 
	
	Modes: Common */
		ESecurityCodePhonePassword,
	/** Service Programming Code (SPC)
	
	Modes: CDMA */
		ESecurityCodeSPC,
	/** Phonebook key to display the hidden entries.
	
	Modes: WCDMA */
		ESecurityHiddenKey,
	/** USIM Application PIN.
	
	Modes: WCDMA */
		ESecurityUSIMAppPin,
	/** Second USIM Application PIN.
	
	Modes: WCDMA */
		ESecuritySecondUSIMAppPin,
	/** Universal PIN.
	
	Modes: WCDMA */
		ESecurityUniversalPin,
	/** Universal PIN unblocking code (always 8 digits).
	
	Modes: Common */
		ESecurityUniversalPuk
		};

	IMPORT_C void ChangeSecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType, const TMobilePhonePasswordChangeV1& aChange) const;

	/** Defines the status of a security code.

	@see GetSecurityCodeInfo()
	@see NotifySecurityCodeInfoChange()
	@publishedPartner
	@released
	*/
	class TMobilePhoneSecurityCodeInfoV5 : public TMultimodeType
		{
	public:
		IMPORT_C TMobilePhoneSecurityCodeInfoV5();
	public:
	/** Number of remaining security code entry attempts before the corresponding lock gets blocked
	
	Modes: Common
	*/
		TInt iRemainingEntryAttempts;
		};
	
	/** A typedef'd packaged TMobilePhoneSecurityCodeInfoV5 for passing through a generic API
	function member. */
	typedef TPckg<TMobilePhoneSecurityCodeInfoV5> TMobilePhoneSecurityCodeInfoV5Pckg;
	
	IMPORT_C void GetSecurityCodeInfo(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aSecurityCode, TDes8& aSecurityCodeInfo) const;
	IMPORT_C void NotifySecurityCodeInfoChange(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode& aSecurityCode, TDes8& aSecurityCodeInfo) const;

/** Notify Security Events.

Modes: Common */
	enum TMobilePhoneSecurityEvent
		{
	/** The phone has detected that there is no ICC present. 
	
	Modes: Common */
		ENoICCFound,
	/** The phone has detected that the ICC is unusable. 
	
	Modes: Common */
		EICCTerminated,
	/** The phone requires PIN1 to be entered. 
	
	Modes: Common */
		EPin1Required,
	/** The phone requires PUK1 to be entered.
	
	Modes: Common */
		EPuk1Required,
	/** The phone requires PIN2 to be entered.
	
	Modes: GSM/WCDMA */
		EPin2Required,
	/** The phone requires PUK2 to be entered.
	
	Modes: GSM/WCDMA */
		EPuk2Required,
	/** The phone requires the Phone Password to be entered. 
	
	Modes: Common */
		EPhonePasswordRequired,
	/** The phone requires the SPC to be entered. 
	
	Modes: CDMA */
		ESPCRequired,
	/** The PIN1 verification procedure has passed. 
	
	Modes: Common */
		EPin1Verified,
	/** The PIN2 verification procedure has passed.

	Modes: GSM/WCDMA */
		EPin2Verified,
	/** The PUK1 unblocking procedure has passed.
	
	Modes: Common */
		EPuk1Verified,
	/** The PUK2 unblocking procedure has passed. 
	
	Modes: GSM/WCDMA */
		EPuk2Verified,
	/** The Phone Password has been verified. 
	
	Modes: Common */
		EPhonePasswordVerified,
	/** The SPC verification procedure has passed.
	
	Modes: CDMA */
		ESPCVerified,
	/** The phone requires the phonebook hidden key to be entered.
	
	Modes: WCDMA */
		EHiddenKeyRequired,
	/** The phonebook hidden key procedure has passed.
	
	Modes: WCDMA */
		EHiddenKeyVerified,
	/** The phone requires the currently active USIM Application PIN to be entered.
	
	Modes: WCDMA */
		EUSIMAppPinRequired,
	/** The currently active USIM Application PIN procedure has passed.
	
	Modes: WCDMA */
		EUSIMAppPinVerified,
	/** The phone requires the currently active USIM Application second PIN to be entered.
	
	Modes: WCDMA */
		ESecondUSIMAppPinRequired,
	/** The currently active USIM Application second PIN procedure has passed.
	
	Modes: WCDMA */
		ESecondUSIMAppPinVerified,
	/** The phone requires the Universal PIN to be entered.
	
	Modes: WCDMA */
		EUniversalPinRequired,
	/** The currently active Universal PIN procedure has passed.
	
	Modes: WCDMA */
		EUniversalPinVerified,
	/** The Service Programming Code has been changed.
	
	Modes: CDMA */
		ESPCChanged,
	/** The phone requires Universal PUK to be entered.
	
	Modes: WCDMA */
		EUniversalPukRequired,
	/** The Universal PUK unblocking procedure has passed.
	
	Modes: WCDMA */
		EUniversalPukVerified
		};

	IMPORT_C void NotifySecurityEvent(TRequestStatus& aReqStatus, TMobilePhoneSecurityEvent& aEvent) const;

	// for use by client-side API code and TSY only

	struct TCodeAndUnblockCode
		{
		TMobilePassword iCode;
		TMobilePassword iUnblockCode;
		};	

	IMPORT_C void VerifySecurityCode(TRequestStatus& aReqStatus, TMobilePhoneSecurityCode aType,
		const TMobilePassword& aCode, const TMobilePassword& aUnblockCode) const;
	IMPORT_C TInt AbortSecurityCode(TMobilePhoneSecurityCode aType) const;

	/***********************************************************************************/	
	// 
	// MobileMessageWaiting
	//
	/***********************************************************************************/

/** Display indicators. */
	enum TMobilePhoneIndicatorDisplay
		{
	/** Display voicemail active. */
		KDisplayVoicemailActive = 0x01,
	/** Display fax active. */
		KDisplayFaxActive = 0x02,
	/** Display E-mail active. */
		KDisplayEmailActive = 0x04,
	/** Display other active. */
		KDisplayOtherActive = 0x08,
	/** Display Aux voicemail active. */
		KDisplayAuxVoicemailActive = 0x10,
	/** Display data active. */
		KDisplayDataActive = 0x20
		};

	class TMobilePhoneMessageWaitingV1 : public TMultimodeType
/** Message Waiting Indicators. See 3GPP TS 31 102.

@see GetIccMessageWaitingIndicators()
@see SetIccMessageWaitingIndicators()
@see NotifyIccMessageWaitingIndicatorsChange() 
*/
		{
	public:
		IMPORT_C TMobilePhoneMessageWaitingV1();
	public:
	/** The flags for each indicator from TMobilePhoneIndicatorDisplay to specify whether 
	the indicator should be displayed or not. E.g. Messages of the specified type are waiting.

	Modes: Common */
		TUint8	iDisplayStatus;
	/** The number of voicemail messages waiting for the "main" voice line.
	
	Modes: Common */
		TUint8	iVoiceMsgs;
	/** The number of voicemail messages waiting for the "auxiliary" voice line.
	
	Modes: GSM */
		TUint8	iAuxVoiceMsgs;
	/** The number of messages waiting for the data line.
	
	Modes: Common */
		TUint8	iDataMsgs;
	/** The number of messages waiting for the fax line.
	
	Modes: Common */
		TUint8	iFaxMsgs;
	/** The number of email messages waiting.
	
	Modes: WCDMA */
		TUint8	iEmailMsgs;
	/** Contains the number of "unspecified" messages waiting.
	
	Modes: WCDMA */
		TUint8	iOtherMsgs;
		};

/** A typedef'd packaged TMobilePhoneMessageWaitingV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneMessageWaitingV1> TMobilePhoneMessageWaitingV1Pckg;

	IMPORT_C void GetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const;
	IMPORT_C void SetIccMessageWaitingIndicators(TRequestStatus& aReqStatus, const TDesC8& aMsgIndicators) const;
	IMPORT_C void NotifyIccMessageWaitingIndicatorsChange(TRequestStatus& aReqStatus, TDes8& aMsgIndicators) const;

	IMPORT_C void NotifyMessageWaiting(TRequestStatus& aReqStatus, TInt& aCount) const;

	/***********************************************************************************/
	//
	// Mobile Fixed Dialling Numbers Functional Unit
	//
	/***********************************************************************************/

/** Fixed Dialling Numbers Status.

Modes: Common */
	enum TMobilePhoneFdnStatus
		{
	/** Fixed Dialling Number mode is supported but is not currently active. */
		EFdnNotActive,
	/** Fixed Dialling Number mode is supported and is currently active. Deactivating 
	FDN mode is supported. */
		EFdnActive,
	/** Fixed Dialling Number mode is supported and is permanently active. Deactivating 
	FDN mode is NOT supported with this SIM. */
		EFdnPermanentlyActive,
	/** Fixed Dialling Number mode is not supported by ME and/or SIM. */
		EFdnNotSupported,
	/** ME is currently unable to determine the status of FDN mode. */
		EFdnUnknown
		};

	IMPORT_C TInt GetFdnStatus(TMobilePhoneFdnStatus& aFdnStatus) const;
	IMPORT_C void GetFdnStatus(TRequestStatus& aReqStatus, TMobilePhoneFdnStatus& aFdnStatus) const;

/** Fixed Dialling Numbers Setting

Modes: Common */
	enum TMobilePhoneFdnSetting
		{
	/** Activate the FDN service. */
		EFdnSetOn,
	/** Deactivate the FDN service. */
		EFdnSetOff
		};

	IMPORT_C void SetFdnSetting(TRequestStatus& aReqStatus, TMobilePhoneFdnSetting aFdnSetting) const;
	IMPORT_C void NotifyFdnStatusChange(TRequestStatus& aReqStatus, TMobilePhoneFdnStatus& aFdnStatus) const;

	/***********************************************************************************/
	//
	// Multicall bearer settings
	//
	/***********************************************************************************/

	class TMobilePhoneMulticallSettingsV1 : public TMultimodeType
/** Multi call settings for version v1.0.

@see GetMulticallParams()
@see NotifyMulticallParamsChange() 
@publishedPartner
@released*/
		{
	public:
		IMPORT_C TMobilePhoneMulticallSettingsV1();
	public:
	/** Maximum number of simultaneous CS bearers allowed - defined by the user. 
	
	Modes: WCDMA */
		TInt iUserMaxBearers;
	/** Maximum number of simultaneous bearers allowed - defined by the service provider.
	
	Modes: WCDMA */
		TInt iServiceProviderMaxBearers;
	/** Maximum number of simultaneous CS bearers supported by the network.
	
	Modes: WCDMA */
		TInt iNetworkSupportedMaxBearers;
	/** Maximum number of simultaneous CS bearers supported by the UE.
	
	Modes: WCDMA */
		TInt iUESupportedMaxBearers;
		};

/** A typedef'd packaged TMobilePhoneMulticallSettingsV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobilePhoneMulticallSettingsV1> TMobilePhoneMulticallSettingsV1Pckg;

	IMPORT_C void GetMulticallParams(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const;
	IMPORT_C void SetMulticallParams(TRequestStatus& aReqStatus, TInt aUserMaxBearers) const;
	IMPORT_C void NotifyMulticallParamsChange(TRequestStatus& aReqStatus, TDes8& aMulticallParams) const;
	
	enum TMobilePhoneMulticallIndicator
	/**
	Indicators for exceeding allowed multiple active bearers.
	*/
		{
		/** The maximum number of multiple active bearers allowed by the service provider has been exceeded. */
		EBearerNetworProviderExceeded,
		/** The maximum number of multiple active bearers allowed by the mobile user  has been exceeded. */
		EBearerUserExceeded
		};
		
	IMPORT_C void NotifyMulticallIndicatorChange(TRequestStatus& aReqStatus, TMobilePhoneMulticallIndicator& aMulticallIndicator) const;

	/***********************************************************************************/
	//
	// MobileNextIncomingCall Functional Unit
	//
	/***********************************************************************************/

/** Incoming Call Types.

Modes: Common */
	enum TMobilePhoneIncomingCallType
		{
	/** MS will receive any type of incoming call.
	
	Modes: Common */
		EIncomingTypeNotSpecified,
	/** MS will request voice bearer for incoming calls.
	
	Modes: Common */
		EIncomingVoice,
	/** MS will request fax bearer for incoming calls 
	
	Modes: Common */
		EIncomingFax,
	/** MS will request data bearer for incoming calls
	
	Modes: Common */
		EIncomingData,
	/** MS will request a data bearer for use by a Multimedia CS call (voice fall back 
	is acceptable) for incoming calls.
	
	Modes: GSM/WCDMA */
		EIncomingMultimediaVoiceFallback,
	/** MS will request a data bearer for use by a Multimedia CS call (voice fall back 
	NOT acceptable) for incoming calls 
	
	Modes: GSM/WCDMA */
		EIncomingMultimediaNoFallback,
	/** The single numbering scheme call mode is alternating voice to fax.
	
	Modes: GSM/WCDMA */
		EIncomingAlternatingVoiceFax,
	/** The single numbering scheme call mode is alternating voice to data.
	
	Modes: GSM */
		EIncomingAlternatingVoiceData,
	/** The single numbering scheme call mode is alternating fax to voice.
	
	Modes: GSM */
		EIncomingAlternatingFaxVoice,
	/** The single numbering scheme call mode is alternating data to voice.
	
	Modes: GSM */
		EIncomingAlternatingDataVoice,
	/** The single numbering scheme call mode is alternating voice then data.
	
	Modes: GSM */
		EIncomingAlternatingVoiceThenData
		};

	IMPORT_C void GetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const;
	IMPORT_C void SetIncomingCallType(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType aCallType, TDes8& aDataParams) const;
	IMPORT_C void NotifyIncomingCallTypeChange(TRequestStatus& aReqStatus, TMobilePhoneIncomingCallType& aCallType, TDes8& aDataParams) const;

	/***********************************************************************************/
	//
	// User-To-User Signalling Functional Unit
	//
	/***********************************************************************************/

/** UUS Settings Requests.

Modes: GSM/WCDMA */
	enum TMobilePhoneUUSSetting         // UUS settings of the phone
		{
	/** UUS is not specified. */
		EIncomingUUSNotSpecified,
	/** MS will accept incoming UUS activation request. */
		EIncomingUUSAccepted,
	/** MS will reject incoming UUS activation request. */
		EIncomingUUSRejected
		};

	IMPORT_C void GetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const;
	IMPORT_C void SetUUSSetting(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting aSetting) const;
	IMPORT_C void NotifyUUSSettingChange(TRequestStatus& aReqStatus, TMobilePhoneUUSSetting& aSetting) const;
	
	/***********************************************************************************/
	//
	// Mobile Smart Card Applications Functional Unit
	//
	/***********************************************************************************/
	
	
	enum { KSmartCardApplicationLabelMaxSize=32 };
	
	/** Smart card application info version v5.0. 
	Modes: Common

	@see GetSmartCardApplicationInfo()
	@publishedPartner
	@released
	*/
	class TSmartCardApplicationInfoV5 : public TMultimodeType
		{
	public:
		IMPORT_C TSmartCardApplicationInfoV5();
	public:
		/** 
		Smart card application identifier.
		*/
		TAID iAID;
		/** 
		Smart card application label. 16 bit USC2 characters string provided by the application 
		provider to be shown to the user for information, e.g. operator name. It is 
		recommended by ETSI/3GPP spec that the application label does not exceed 32 
		bytes.
		
		The application label is optional. If no label is provided, the buffer should 
		be NULL.
		 */
		TBuf8<KSmartCardApplicationLabelMaxSize> iLabel;
		};

	/**
	A typedef'd packaged TSmartCardApplicationInfoV5 for passing through a generic API 
	function member. 
	*/	
	typedef TPckg<TSmartCardApplicationInfoV5> TSmartCardApplicationInfoV5Pckg;

	/**
	Specifies the max length of the buffer used to retrieve the smart
	card application's supported EAP method list.  Value 255 since EAP
	type list length fits into one byte (see table 5.1 of ETSI TS
	102.310 v6.2.0).

	@see RMobilePhone::GetSmartCardApplicationInfo()
	@see RMobilePhone::TUiccApplicationEapInfoV6::iEapTypeList
	*/
	enum { KEapSupportedTypeListSize = 255 };

	/**
	UICC application info version v6.0.  Is a
	TSmartCardApplicationInfoV5 object, but has an additional buffer
	(iEapTypeList) for retrieving a list supported EAP methods on the
	application.

	Modes: GSM/WCDMA

	@see RMobilePhone::GetSmartCardApplicationInfo()
	@publishedPartner
	@released
	*/
	class TUiccApplicationEapInfoV6 : public TSmartCardApplicationInfoV5
		{
	public:
		IMPORT_C TUiccApplicationEapInfoV6();

	public:
		/**
		Application EAP support type list, defining the EAP methods
		supported by the UICC application (see RFC 3748 and
		http://www.iana.org/assignments/eap-numbers).
		
		As reference, also worth seeing section 5.2 of ETSI TS 102.310
		v6.2.0 and section 6.2 of RFC3748.

		@see KETelSmartCardEapTypeMD5
		@see KETelSmartCardEapTypeTLS
		@see KETelSmartCardEapTypeSIM
		@see KETelSmartCardEapTypeAKA
		@see KETelSmartCardEapTypeTTLS
		*/
		TBuf8<KEapSupportedTypeListSize> iEapTypeList;	
		};

	/**
	A typedef'd packaged TEapUiccApplicationInfoV6 for passing through
	a generic API function member.

	@see RMobilePhone::GetSmartCardApplicationInfo()
	*/	
	typedef TPckg<TUiccApplicationEapInfoV6> TUiccApplicationEapInfoV6Pckg;

	/**
	Smart card application notification events
	
	Modes: Common
	*/	
	enum TSmartCardApplicationEvent
		{
		/**
		Smart card application has been installed.
		*/
		EScApplicationInstalled,
		/**
		Smart card application has been removed.
		*/
		EScApplicationRemoved,
		/**
		Smart card application has been activated.
		*/
		EScApplicationActivated,
		/**
		Smart card application has been terminated.
		*/
		EScApplicationTerminated
		};

	/**
	Smart card application status.

	Modes: Common
	*/
	enum TSmartCardApplicationAction
		{
		/**
		Smart card application will be activated.
		*/
		EScApplicationActivate,
		/** 
		Smart card application will be terminated.
		*/
		EScTerminate
		};

	/**
	Smart card application file types. For definitions see TS 102.221.
	
	Modes: Common
	*/		
	enum TScFileType
		{
		/**
		Smart card file type is unknown.
		*/
		EUnknown,
		/**
		Smart card file type is linear fixed. 
		
		This is a record-based file.
		*/
		ELinearFixed,
		/**
		Smart card file type is cyclic. 
		
		This is a record-based file.
		*/
		ECyclic,
		/**
		Smart card file type is transparent. 
		
		This is a binary file.
		*/
		ETransparent
		};

	/**
	Typedef to hold a 2-byte file identifier.
	*/
	typedef TUint16 TScFileID;

	/** Smart card application file info version v5.0.
	Modes: Common

	@see GetScFileInfo()
	@publishedPartner
	@released
	*/
	class TScFileInfoV5 : public TMultimodeType
		{
	public:
		IMPORT_C TScFileInfoV5();
	public:
		/**
		Smart card file identifier.
		*/
		TScFileID iFileID;
		/**
		The type of the smart card file. Options are
		Linear Fixed, Cyclic or Transparent.
		*/
		TScFileType iType;
		/**
		Total length of the file.  As specified in TS 102.221 the maximum length of an EF is 0xFFF bytes.
		*/
		TInt iTotalLength;
		/**
		If the file is a record based file (e.g. file type is ELinearFixed or ECyclic) then this gives the fixed length of a record in the file.
		If file type is ETransparent then this value is unused and will be set to 0. 
		
		From TS 102.221 the maximum length of a record in an EF is 255 bytes.
		*/
		TInt iRecordLength;
		/**
		If the file is a record based file (e.g. file type is ELinearFixed or ECyclic) then this gives the number of records in the file.
		If file type is ETransparent then this value is unused and will be set to 0. 
		
		From TS 102.221 the maximum number of records in an EF is 254.
		*/
		TInt iNumberRecords;
		};
	
	
	/** A typedef'd packaged TScFileInfoV5 for passing through a generic API 
	function member. 
	*/
	typedef TPckg<TScFileInfoV5> TScFileInfoV5Pckg;
	
	/**
	This based on the maximum number of bytes in a command PDU 
	as defined in TS 102.221 however the actual path string is very unlikely to ever be this big.
	
	Modes: Common
	*/
	enum{ KMaxScFilePathLength = 256};
	
	/**
	A typedef'd buffer to hold the path to an EF file.  
	*/
	typedef TBuf8<KMaxScFilePathLength> TScFilePathReference;
	
	
	 /** 
	 Class that holds a smart card applications AID and associated file path string.

	 Modes: Common

	 @see GetScFileInfo()
	 @publishedPartner
	 @released
	 */
	 class TScFilePath
		{
	 public:
		IMPORT_C TScFilePath();
     public:
     	/** 
     	AID of application. This may be empty implying the iPath is a path reference starting at the master file (MF).
     	*/
		TAID iAID;
		/**
		Full path reference to file.  
		
		The iPath must define the file path using full path referencing. This is because the client does not know 
		what is the currently selected EF or DF and it is therefore necessary to select the file by full
		path referencing from the master file.  
		
		If iAID value is empty then the iPath reference starts from the MF file but should not include the file ID of the MF (3F00) itself.
		E.g. To reference the EF_DIR - iAID would be empty and iPath would be set to "2F00".
		E.g. To refefence the EF_SMS under DF_TELECOM on a 2G SIM ICC - iAID would be empty and iPath would be set to "7F106F3C".
		
		If iAID is non-empty then it refers to the AID of the application and iPath is a path reference to a file in that application,
		In this situation the path reference may start with the implicit FID of the application DF (7FFF).  
		E.g.  The path to reference to the EF_SMS file in a USIM application using implicit ADF FID would 
		be "7FFF6F3C".
		
		See TS102.221 section 8.4.2 for more information.  
		*/
		TScFilePathReference iPath;
		};
		
	/** Smart card application file identifier and access offsets.  This class is used to identify a file and the 
	location in a file to either read or write. Inherits attributes from TScFilePath which provide the 
	parent AID and full path reference.
	
	Modes: Common

	@see TScFilePath
	@see ReadScFile()
	@see UpdateScFile()
	@publishedPartner
	@released
	*/
	class TScFilePathWithAccessOffsets : public TScFilePath
		{
	public:
		IMPORT_C TScFilePathWithAccessOffsets();
	public:
		/**
		The type of the smart card file. Options are
		Linear Fixed, Cyclic or Transparent.
		*/
		TScFileType iType;
		/**
		If file type is ELinearFixed or ECyclic then this is the starting record index to read or update.
		This must be less than the number of records in the file.

		If file type is ETransparent then this is the offset (in bytes) from the start of the transparent file to read or update.
		This must be less than the total file size.
		*/
		TUint iStartOffset;
		/**
		If the file type is ELinearFixed or ECyclic then this is unused.
		NOTE: A call to ReadScFile or UpdateScFile for a record based file type will only read or update
		one record as described in TS 102.221 READ RECORD and UPDATE RECORD.

		If file type is ETransparent then this is the number of bytes to read or update.
		*/
		TUint iCount;
		};

	IMPORT_C void EnumerateSmartCardApplications(TRequestStatus& aReqStatus, TUint& aCount) const;
	IMPORT_C void GetSmartCardApplicationInfo(TRequestStatus& aReqStatus, TUint aAppIndex, TDes8& aInfo) const;
	IMPORT_C void NotifySmartCardApplicationInfoChange(TRequestStatus& aReqStatus, TAID& aAID, TSmartCardApplicationEvent& aEvent) const;
	IMPORT_C void SetSmartCardApplicationStatus(TRequestStatus& aReqStatus, const TAID& aAID, TSmartCardApplicationAction aAppAction) const;
	IMPORT_C void GetScFileInfo(TRequestStatus& aReqStatus, const TScFilePath& aFilePathId, TDes8& aInfo) const;
	IMPORT_C void ReadScFile(TRequestStatus& aReqStatus, const TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8& aReadBuffer) const;
	IMPORT_C void UpdateScFile(TRequestStatus& aReqStatus, const TScFilePathWithAccessOffsets& aFilePathOffsets, TDes8& aUpdateBuffer) const;
	
	/***********************************************************************************/
	//
	// Mobile USIM Applications Functional Unit
	//
	/***********************************************************************************/

	enum { KUSimApplicationLabelMaxSize=32 };

	IMPORT_C void EnumerateUSimApplications(TRequestStatus& aReqStatus, TInt& aCount, TAID& aActiveAID) const; //deprecated 9.1

	class TUSimApplicationInfoV2 : public TMultimodeType
	/** USIM application information for version v2.0. 
		
	@deprecated 9.1 Use @see TSmartCardApplicationInfoV5 instead.
	*/
		{
	public:
		IMPORT_C TUSimApplicationInfoV2();
	public:
	/** USIM Application identifier.

	Modes: WCDMA */
		TAID								iAID;
	/** USIM Application label. 16 bit USC2 characters string provided by the application 
	provider to be shown to the user for information, e.g. operator name. It is 
	recommended by ETSI/3GPP spec that the application label does not exceed 32 
	bytes.
	
	The application label is optional. If no label is provided, the buffer should 
	be NULL.
	
	Modes: WCDMA */
		TBuf8<KUSimApplicationLabelMaxSize> iLabel; 
	};

	/** A typedef'd packaged TUSimApplicationInfoV2 for passing through a generic API 
	function member. 

	@deprecated 9.1 Use @see TSmartCardApplicationInfoV5 instead.
	*/
	typedef TPckg<TUSimApplicationInfoV2> TUSimApplicationInfoV2Pckg;

	IMPORT_C void GetUSimApplicationInfo(TRequestStatus& aReqStatus, TInt aUSimAppIndex, TDes8& aInfo) const; //deprecated 9.1
	IMPORT_C void NotifyUSimApplicationsInfoChange(TRequestStatus& aReqStatus, TInt& aCount, TAID& aActiveAID) const; //deprecated 9.1

	/** USIM Application Status.

	Modes: WCDMA 

	@deprecated 9.1 Use @see TSmartCardApplicationAction instead.
	*/
	enum TUSimAppAction
		{
	/** USIM application will be activated.
	
	Modes: WCDMA */
		EUSimActivate,
	/** USIM application will be terminated.
	
	Modes: WCDMA */
		EUSimTerminate
		};

	IMPORT_C void SetUSimApplicationStatus(TRequestStatus& aReqStatus, const TAID aAID, TUSimAppAction aUsimAppAction) const; //deprecated 9.1

	/** USIM Application selection mode.

	Mode: WCDMA */
	enum TUSimSelectionMode
		{
	/** USIM application is selected automatically by phone.
	
	Mode: WCDMA */
		EUSimSelectionAutomatic,
	/** USIM application is selected manually by user.
	
	Mode: WCDMA */
		EUSimSelectionManual
		};

	IMPORT_C TInt SetUSimAppsSelectionMode(TUSimSelectionMode aUSimSelectionMode) const;
	IMPORT_C TInt GetUSimAppsSelectionMode(TUSimSelectionMode& aUSimSelectionMode) const;
	IMPORT_C void NotifyUSimAppsSelectionModeChange(TRequestStatus& aReqStatus, TUSimSelectionMode& aUSimSelectionMode) const;
	IMPORT_C void GetCurrentActiveUSimApplication(TRequestStatus& aReqStatus, TAID& aAID) const;
	
	/***********************************************************************************/
	//
	// Mobile MMS Functional Unit
	// 
	/***********************************************************************************/
	
	/** max size of MMS notification buffer. */
	enum{KMaxMmsNotification = 253};
	
	/**
	Identifies current status of MMS.
	*/
	enum TMmsStatus
		{
		/**
		The MMS has not been retrieved.
		*/
		EMmsNotRetrieved,
		/**
	    The MMS has been retrieved.
	    */
		EMmsRetrieved,
		/**
		The MMS has been rejected.
		*/
		EMmsRejected,
		/**
		The MMS has been forwarded.
		*/
		EMmsforwarded
		};

	/** 
	MMS Implementation.
	*/
	enum TMmsImplementation
		{
		/**
		Unknown implementation for MMS.
		*/
		KMmsImplUnknwown=0x00,
		/**
		Wap implementation for MMS.
		*/
		KWapImplementation=0x01
		};
	
	/**
	MMS Connectivity settings.
	*/
	enum TMmsConnParams
		{
		/**
		MMS User Preferences.
		*/
		EUserPreferences,
		/**
		MMS Issuer Connectivity Parameters.
		*/
		EIssuerConnParams,
		/**
		MMS User Connectivity Parameters.
		*/
		EUserConnParams
		};

	/**
	MMS field Id tags.
	*/
	enum TMobileMMSFieldTags
		{
		/**
		Tag id for MMS connectivity parameters.
		*/
		ETagMmsConnParams=0xAB,
		/**
		Tag id for MMS Implementation.
		*/
		ETagMmsImpl=0x80,
		/**
		Tag id for MMS Relay/Server.
		*/
		ETagMmsServer=0x81,
		/**
		Tag id for Interface to Core Network and Bearer.
		*/
		ETagMmsBearerIE=0x82,
		/**
		Tag id for Gateway.
		*/
		ETagMmsGateway=0x83 	  
		};
		
	class TMmsNotificationV3 : public TMultimodeType
	/**
	Class containing MMS notification paramters.
	*/
		{
		public :
			IMPORT_C TMmsNotificationV3();
		public :
			/**
			Free/Used space.
			*/
			TBool iSpace;
			/**
			Notification read/not read.
			*/
			TBool iNotification;
			/**
			MMS status.
			*/
			TMmsStatus iMmsStatus;
			/**
			MMS implementation.
			*/
			TMmsImplementation iImplementation;
			/**
			MMS notification buffer.
			*/
			TBuf8<KMaxMmsNotification> iNotify;
		};
	
	typedef TPckg<TMmsNotificationV3> TMmsNotificationV3Pckg;

	//	MMS notification 	
	IMPORT_C void NotifyMmsUpdate(TRequestStatus& aReqStatus, TDes8& aNotification) const;
	IMPORT_C void SetMmsUserConnParams(TRequestStatus& aReqStatus, TDes8& aConnectivity) const;
	IMPORT_C void SetMmsUserPreferences(TRequestStatus& aReqStatus, TDes8& aPreferences) const;
	IMPORT_C void GetMmsConfig(TRequestStatus& aReqStatus, const TMmsConnParams aType, TDes8& aConnectivity) const;
	IMPORT_C void NotifyMmsConfig(TRequestStatus& aReqStatus, const TMmsConnParams aType, TDes8& aConnectivity) const;
	
	/***********************************************************************************/
	//
	// Mobile MailBox Numbers Functional Unit 
	// 
	/***********************************************************************************/

	class TMobilePhoneVoicemailIdsV3 : public TMultimodeType
	/**
	Contains mailbox numbers.
	*/
		{
		public :
			IMPORT_C TMobilePhoneVoicemailIdsV3();
		public :
			/**
			Phonebook entry for "voicemail" mailbox number.
			*/
			TUint8	iVoice;
			/** 
			Phonebook entry for "data" mailbox number.
			*/
			TUint8	iData;
			/**
			Phonebook entry for "fax" mailbox number.
			*/
			TUint8	iFax;
			/**
			Phonebook entry for "other" mailbox number.
			*/
			TUint8	iOther;
		};
	
	typedef TPckg<TMobilePhoneVoicemailIdsV3> TMobilePhoneVoicemailIdsV3Pckg;

	IMPORT_C void GetMailboxNumbers(TRequestStatus& aReqStatus, TDes8& aMailBox) const;
	IMPORT_C void NotifyMailboxNumbersChange(TRequestStatus& aReqStatus, TDes8& aMailBox) const;

	/***********************************************************************************/
	//
	// Mobile APN Control List Functional Unit
	// 
	/***********************************************************************************/	
	
	enum { KMaxApnName = 100 };
	
	class TAPNEntryV3 : public TMultimodeType
	/**
	Contains parameters for an Access Point Name (APN) entry contained 
	within the Access Control List EFacl file in the UICC.
	*/
		{
	public:
		IMPORT_C TAPNEntryV3();
	public:
		/**
		GGSN DNS name.
		*/
		TBuf8<KMaxApnName> iApn;		
		};
		
	typedef TPckg<TAPNEntryV3> TAPNEntryV3Pckg;
	
	IMPORT_C void EnumerateAPNEntries(TRequestStatus& aReqStatus, TUint32 &aIndex) const;
	IMPORT_C void GetAPNname(TRequestStatus& aReqStatus, const TUint32 aIndex, TDes8& aAPN) const;
	IMPORT_C void AppendAPNName(TRequestStatus& aReqStatus, const TDes8& aAPN) const;
	IMPORT_C void DeleteAPNName(TRequestStatus& aReqStatus, TUint32 aIndex) const; 
	IMPORT_C void NotifyAPNListChanged(TRequestStatus& aReqStatus) const;

	enum TAPNControlListServiceStatus {
		/**
		The APN control list service is disabled.
		*/
		EAPNControlListServiceDisabled,
		/**
		The APN control list service is enabled.
		*/
		EAPNControlListServiceEnabled
	};

	IMPORT_C void SetAPNControlListServiceStatus(TRequestStatus& aReqStatus, TAPNControlListServiceStatus aAPNControlListServiceStatus) const;
	IMPORT_C void GetAPNControlListServiceStatus(TRequestStatus& aReqStatus, TAPNControlListServiceStatus& aAPNControlListServiceStatus) const;
	IMPORT_C void NotifyAPNControlListServiceStatusChange(TRequestStatus& aReqStatus, TAPNControlListServiceStatus& aAPNControlListServiceStatus) const;

	/***********************************************************************************/
	//
	// Retrieve Total Air Time Duration Functional Unit
	//
	/***********************************************************************************/
	IMPORT_C TInt GetAirTimeDuration(TTimeIntervalSeconds& aTime) const;
	IMPORT_C void NotifyAirTimeDurationChange(TRequestStatus& aReqStatus,TTimeIntervalSeconds& aTime) const;
	/***********************************************************************************/
	//
	// Terminate All Calls
	//
	/***********************************************************************************/
	IMPORT_C void TerminateAllCalls(TRequestStatus& aReqStatus) const;
	
	/***********************************************************************************/
	//
	// Auto Redial Functional Unit
	//
	/***********************************************************************************/
	IMPORT_C void ClearBlacklist(TRequestStatus& aReqStatus) const;

	/***********************************************************************************/
	//
	// Mobile Personalisation Functional Unit
	//
	/***********************************************************************************/
	
	/**
	Indentifies the personalisation scheme capabilities of the UICC/ME.
	*/
	enum TMobilePhonePersonalisationCaps
		{
		/**
		UICC/ME personalisation based on network (MCC, MNC) information is possible.
		*/
		KCapsPersonalisedNetwork=0x01,
		/**
		UICC/ME personalisation based on network (MCC, MNC, IMSI network code group) information is possible.
		*/
		KCapsPersonalisedNetworkSub=0x02,
		/**
		UICC/ME personalisation based on network (MCC, MNC, EFGID1, EFCNL) information is possible.
		*/
		KCapsPersonalisedServiceProvider=0x04,
		/**
		UICC/ME personalisation based on network (MCC, MNC, EFGID1, EFGID2, EFCNL) information is possible.
		*/
		KCapsPersonalisedCorporate=0x08,
		/**
		UICC/ME personalisation based on (IMSI SIM/USIM code group) information is possible.
		*/
		KCapsPersonalisedUSim=0x10
		};
		
	/**
	Identifies the current personalisation schemes that are active. 
	*/
	enum TMobilePhonePersonalisationScheme
		{
		/**
		The ME is personalised under the network scheme.
		*/
		KPersonalisedNetwork=0x01,
		/**
		The ME is personalised under the network sub scheme.
		*/
		KPersonalisedNetworkSub=0x02,
		/**
		The ME is personalised under the service provider scheme.
		*/
		KPersonalisedServiceProvider=0x04,
		/**
		The ME is personalised under the corprorate scheme.
		*/
		KPersonalisedCorporate=0x08,
		/**
		The ME is personalised under the  SIM/USIM scheme.
		*/
		KPersonalisedUSim=0x10	
		};

	/**
	Identifies the personalisation scheme to be set.
	*/
	enum TMobilePhonePersonalisation
		{
		/**
		Personalise the ME using the network scheme.
		*/
		EPersonaliseNetwork,
		/**
		Personalise the ME using the network sub scheme.
		*/
		EPersonaliseNetworkSub,
		/**
		Personalise the ME using the service provider scheme.
		*/
		EPersonaliseServiceProvider,
		/**
		Personalise the ME using the corporate scheme.
		*/
		EPersonaliseCorporate,
		/**
		Personalise the ME using the SIM/USIM scheme.
		*/
		EPersonaliseUsim
		};
		
	IMPORT_C TInt GetPersonalisationCaps(TUint32& aCaps) const;
	IMPORT_C void GetPersonalisationStatus(TRequestStatus& aReqStatus, TUint32& aPersSchemes) const;
	IMPORT_C void SetPersonalisationStatus(TRequestStatus& aReqStatus, const TMobilePhonePersonalisation aPersSchemes, const TDes& aPersCode) const;
	
	/***********************************************************************************/
	//
	// Etel 3rd Party v1.0 Parameter classes
	//
	/***********************************************************************************/
	
	class TEtel3rdPartyMobileNetworkInfoV1 : public TMultimodeType
	/**
	Defines the parameters used to set-up of a call originated from an ETel 3rd Party client.

	TEtel3rdPartyMobileNetworkInfoV1 was used to give an indication to the TSY of where the
	request was originating from; i.e. if the request is from an application using the ISV
	API or ETel API, which allowed the TSY to make a decision based on the origin.  This
	data type also provided further protection by not including any location information
	parameters.  With PlatSec being introduced in v9.0, there was no need to use this data
	structure, as each API is policed with the adequate PlatSec capabilities.  Therefore,
	in v9.0 TEtel3rdPartyMobileNetworkInfoV1 was deprecated and removed from the ETel ISV
	(ETel3rdParty) implementation.

	TEtel3rdPartyMobileNetworkInfoV1 was only used internally by the ETel ISV API when calls
	are made to RMobilePhone::GetCurrentNetwork or RMobilePhone::NotifyCurrentNetworkChange.
	The TSY no longer needs to support this as ETel ISV now uses the TMobilePhoneNetworkInfoV2
	data structure and no distinction is required for ISV Apps.

	@publishedPartner
	@deprecated 9.0 This class has been deprecated from 9.0 and should no longer be used.
	*/
		{
	public:
		IMPORT_C TEtel3rdPartyMobileNetworkInfoV1();
	public:
	/** Mode of the network.
	Modes: Common
	
	@see TMobilePhoneNetworkMode */
		TMobilePhoneNetworkMode iMode;
	/** Status of the network
	
	Modes: Common
	
	@see TMobilePhoneNetworkStatus */
		TMobilePhoneNetworkStatus iStatus;
	/** The band and band class of the CDMA network operator.
	
	Modes: CDMA
	
	@see TMobilePhoneNetworkBandInfo */
		TMobilePhoneNetworkBandInfo iBandInfo;
	/** The MCC of the network.
	
	Modes: Common
	
	@see TMobilePhoneNetworkCountryCode */
		TMobilePhoneNetworkCountryCode iCountryCode;
	/** The system identity (SID) of the CDMA network or the system identity (SID) of the AMPS network.
	
	Modes: CDMA

	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iCdmaSID;
	/** The network identity (NID in CDMA and MNC in GSM).
	
	Modes: Common
	
	@see TMobilePhoneNetworkIdentity */
		TMobilePhoneNetworkIdentity iNetworkId;
	/** The alpha-tag displayed when this is the serving network.
	
	Modes: Common
	
	@see TMobilePhoneNetworkDisplayTag */
		TMobilePhoneNetworkDisplayTag iDisplayTag;
	/** The short name (up to 10 characters) of the network operator.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkShortName */
		TMobilePhoneNetworkShortName iShortName;
	/** The long name (up to 20 characters) of the network operator.
	
	Modes: GSM/WCDMA
	
	@see TMobilePhoneNetworkLongName */
		TMobilePhoneNetworkLongName iLongName;
	/** The type of network access.
	
	@see TMobilePhoneNetworkAccess */
		TMobilePhoneNetworkAccess iAccess;
		};

/** A typedef'd packaged TEtel3rdPartyMobileNetworkInfoV1 for passing through a generic
API function member.

@deprecated 9.0
*/
	typedef TPckg<TEtel3rdPartyMobileNetworkInfoV1>  TEtel3rdPartyMobileNetworkInfoV1Pckg;

	/** IMS Authenticate constants,in accordance to 3GPP TS 33.102,
	section 6.3.7, and RFC 3310*/
	enum TMobilePhoneAuthenticate
		{
		/** length of autn is 128bits - 16octets*/
		KAutnLength=16,
		/** length of RAND is 16 octets */
		KRandLength=16,
		/** length of RES is 16 octets*/
		KResLength=16,
		/** length of IK is 16 octets*/
		KIkLength=16,
		/** length of CK is 16 octets*/
		KCkLength=16,
		/** length of Kc (GSM cipher key) is 8 octets*/
		KKcLength=8,
		/** length of is 112 bits - 14 octets */
		KAutsLength=14,
		};

	/** Maximum size of the record in an EF is 0xff( 255 bytes) according to TS 102.221, section 8.2.2.2
	*/
	enum TMobilePhoneRelease5EFMaxSize
	{
	 KRelease5EFMaxSize=255,
	};
	
	/** typedefs for encapsulation of the buffers that hold authorization data stored on the ISIM/USIM*/
	/** typedef for Internet Multimedia Public Identity*/	
	typedef TBuf8<KRelease5EFMaxSize> TIMPU;
	/** typedef for Internet Multimedia Private Identity*/
	typedef TBuf8<KRelease5EFMaxSize> TIMPI;
	/** typedef for Home Network Domain Name*/
	typedef TBuf8<KRelease5EFMaxSize> THNDN;


	/** IMS Authenticate API*/
	/** Class encapsulates data needed as an input/output for
	ISIM/USIM AUTHENTICATE command
	
	@publishedPartner
	@released
	*/
	class TImsAuthenticateDataV5: public TMultimodeType
		{
	public:
		IMPORT_C TImsAuthenticateDataV5();
		/** holds value of network challenge AUTN */
		TBuf8<KAutnLength> iAUTN;
		/** holds value of network challenge RAND */
		TBuf8<KRandLength> iRAND;
		/** holds result RES of AUTHENTICATE command when it's successfull*/
		TBuf8<KResLength> iRES;
		/** holds value of session key Integrity Key */
		TBuf8<KIkLength> iIK;
		/** holds value of session key Cipher Key */
		TBuf8<KCkLength> iCK;
		/** holds value of Authentication Token when  AUTHENTICATE fails*/
		TBuf8<KAutsLength> iAUTS;
		};

	/** packaged version of TImsAuthenticateDataV5, used when this structure has to be passeed via IPC*/
	typedef TPckg<TImsAuthenticateDataV5> TImsAuthenticateDataV5Pckg;
	friend class CAsyncRetrieveAuthorizationInfo;

	/** API that execute ISIM/USIM AUTHENTICATE command*/
	IMPORT_C void ImsAuthenticate (TRequestStatus& aReqStatus,TDes8& authenticateDataPckgd) const;

	IMPORT_C void NotifyImsAuthorizationInfoChange(TRequestStatus& aReqStatus) const;

	/**
	Source location of IMS Authorization data.
	*/
	enum TAuthorizationDataSource
		{
		/** Authorization data source is USIM. */
		EFromUSIM,
		/** Authorization data source is ISIM. */
		EFromISIM
		};

	/** 
	Class encapsulates IMS authorization data stored in the ISIM or USIM

	@publishedPartner
	@released
	*/
	class CImsAuthorizationInfoV5 : public CBase	
		{
	public:
		IMPORT_C ~CImsAuthorizationInfoV5();
		IMPORT_C static CImsAuthorizationInfoV5* NewL();
		IMPORT_C virtual void ExternalizeL(HBufC8*& aBuffer);
		IMPORT_C virtual void InternalizeL(const TDesC8& aBuffer);
		IMPORT_C TUint ExtensionId() const;
	public:
		/**Internet Multimedia Private Identity stored on the ISIM/USIM*/
		RMobilePhone::TIMPI iIMPI;
		/**Internet Multimedia Public Identity(ies) stored on the ISIM/USIM*/
		RArray<RMobilePhone::TIMPU> iIMPUArray;
		/**Home Network Domain Name stored on the ISIM/USIM*/
		RMobilePhone::THNDN iHomeNetworkDomainName;
		/**indicates whether authorization data has been retrieved from the ISIM*/
		TAuthorizationDataSource iAuthenticationDataSource;
	protected:
		CImsAuthorizationInfoV5();
		/** version of the data supported*/
		TUint iExtensionId;
		};
		
	/**	
	Defines the input as well as the ouput parameters used when performing the
	(U)ICC AUTHENTICATE command.

	@publishedPartner
	@released
    */
	class TSmartCardAuthenticateDataV6 : public TImsAuthenticateDataV5
		{
	public:
		IMPORT_C TSmartCardAuthenticateDataV6();

	public:
		TBuf8<KKcLength> iKc;
		};

	/**
	Packaged version of TSmartCardAuthenticateDataV6, used when this
	structure has to be passeed via IPC.
	*/
	typedef TPckg<TSmartCardAuthenticateDataV6> TSmartCardAuthenticateDataV6Pckg;

	IMPORT_C void SmartCardAuthenticate(TRequestStatus& aReqStatus, TDes8& aAuthDataPckgd) const;
	IMPORT_C void SmartCardAuthenticate(TRequestStatus& aReqStatus, const TAID& aAID, TDes8& aAuthDataPckgd) const;

private:
	CMobilePhonePtrHolder* iMmPtrHolder;
	RMobilePhone(const RMobilePhone& aPhone);

protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};


/*********************************************************/
//
// Phone Storage functionality (RMobilePhoneStore)
//
/*********************************************************/



class CMobilePhoneStorePtrHolder;
class RMobilePhoneStore : public RTelSubSessionBase
/**
Abstract class used to define common phone storage actions and types

Clients open one of the specialised phone store classes that are derived from RMobilePhoneStore
*/
	{
public:
	friend class CAsyncRetrieveStoreList;

/** Types of store.

Modes: Common */
	enum TMobilePhoneStoreType
		{
	/** Store type is unknown.
	
	Modes: Common */
		EPhoneStoreTypeUnknown,
	/** Store contains SMS messages.
	
	Modes: Common */
		EShortMessageStore,
	/** Store contains NAM entries.
	
	Modes: CDMA */
		ENamStore,
	/** Store contains PhoneBook entries.
	
	Modes: Common */
		EPhoneBookStore,
	/** Store contains emergency number entries.
	
	Modes: Common */
		EEmergencyNumberStore,
	/** Store contains own number entries.

	Modes: Common */
		EOwnNumberStore
		};

/** Store capabilities. */
	enum TMobilePhoneStoreCaps
		{
	/** The store can be accessed as a whole using the ReadAll() and StoreAll() member
	functions. */
		KCapsWholeStore			= 0x80000000,
	/** The store can be accessed one entry at a time using the RMobilePhoneStore::Read(), 
	RMobilePhoneStore::Write() and RMobilePhoneStore::Delete() member functions. */
		KCapsIndividualEntry	= 0x40000000,
	/** The store can be accessed in order to read entries. */
		KCapsReadAccess			= 0x20000000,
	/** The store can be accessed in order to write or delete entries. */
		KCapsWriteAccess		= 0x10000000,
	/** The TSY supports deleting all the store entries at once. */
		KCapsDeleteAll			= 0x08000000,
	/** The TSY supports notification of store events such as entries added, deleted
	or store becoming full. */
		KCapsNotifyEvent		= 0x04000000
		};

/** The type of store information. As defined in TMobilePhoneStoreInfoV1::iExtensionId

Modes: Common

@see TMobilePhoneStoreInfoV1
@see RMobilePhone::TMultimodeType */
	enum TMobilePhoneStoreInfoExtId
		{
	/** The iExtensionId contents indicate that the packaged class is a RMobilePhoneStore::TMobilePhoneStoreInfoV1.
	Modes: Common */
		KETelMobilePhoneStoreV1=KETelExtMultimodeV1,
	/** The iExtensionId contents indicate that the packaged class is a RMobilePhoneBookStore::TMobilePhoneBookInfoV1.
	Modes: Common */
		KETelMobilePhonebookStoreV1,
	/** Reserved for SMS store specific information class.
	Modes: Common */
		KETelMobileSmsStoreV1,
	/** The iExtensionId contents indicate that the packaged class is a RMobileNamStore::TMobileNamStoreInfoV1.
	Modes: CDMA */
		KETelMobileNamStoreV1,
	/** The iExtensionId contents indicate that the packaged class is a RMobileONStore::TMobileONStoreInfoV1.
	Modes: Common */
		KETelMobileONStoreV1,
	/** Reserved for Emergency Number store specific infoprmation class.
	Modes: Common */
		KETelMobileENStoreV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobilePhoneBookInfoV2.
	Modes: Common */
		KETelMobilePhonebookStoreV2=KETelExtMultimodeV2,
		
	/** The iExtensionId contents indicate that the packaged class is a TMobilePhoneBookInfoV2.
 	Modes: Common */
 		KETelMobilePhonebookStoreV5=KEtelExtMultimodeV5
		};



	class TMobilePhoneStoreInfoV1 : public RMobilePhone::TMultimodeType
/** Defines information and capabilities of a phone-side store.
@publishedPartner
@released */
		{
	public:
		IMPORT_C TMobilePhoneStoreInfoV1();

	/** The type of entry in the phone-side store. 
	
	Modes: Common

	@see TMobilePhoneStoreType */
		TMobilePhoneStoreType		iType;
	/** Indicates the total number of entries that may be held in this store. */
		TInt						iTotalEntries;
	/** Indicates the current number of entries held in this store.
	
	Is equal to KIndexNotUsed if the TSY is unable to determine current number 
	of entries.
	
	Modes: Common */
		TInt						iUsedEntries;
	/** Indicates the capabilities of the store. It is the sum of caps constants defined
	in TMobilePhoneStoreCaps and those defined for a specialised phone store.
	
	Modes: Common */
		TUint32						iCaps;
	/** The name of the phone-side store. A valid list of names is given in the description 
	of each specialised store. 
	
	Modes: Common

	@see RMobilePhone::TMobileName */
		RMobilePhone::TMobileName	iName;
		};

/** A typedef'd packaged TMobilePhoneStoreInfoV1 for passing through a generic
API member function. */
	typedef TPckg<TMobilePhoneStoreInfoV1> TMobilePhoneStoreInfoV1Pckg;

	

	class TMobilePhoneStoreEntryV1 : public RMobilePhone::TMultimodeType
/** Defines common contents of an entry in a phone-side store. 
*/
		{
	public:

		enum
			{
			KIndexNotUsed = -1
			};

	protected:
		TMobilePhoneStoreEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** The slot location of the entry within phone-side storage.
	
	Modes: Common */
		TInt  iIndex;
		};

	IMPORT_C void GetInfo(TRequestStatus& aReqStatus, TDes8& aInfo) const;

	IMPORT_C void Read(TRequestStatus& aReqStatus, TDes8& aEntry) const;
	IMPORT_C void Write(TRequestStatus& aReqStatus, TDes8& aEntry) const;

	IMPORT_C void Delete(TRequestStatus& aReqStatus, TInt aIndex) const;
	IMPORT_C void DeleteAll(TRequestStatus& aReqStatus) const;

/** The store events. It is possible for more than one event to occur at the same 
time, therefore the events are a bitmask and should be tested as a bitmask.

Modes: Common

@see NotifyStoreEvent() */
	enum TMobileStoreEvent
		{
	/** The store has become full. This event will trigger after the last possible 
	entry in a store has been written. */
		KStoreFull =0x00000001,
	/** The store was full but now has some space. This event will trigger after one 
	or more entries have been deleted from a full store. */
		KStoreHasSpace =0x00000002,
	/** The store is empty. This event will trigger after the last entry in a store 
	has been deleted or if all entries are deleted at once. */
		KStoreEmpty =0x00000004,
	/** The store has a new entry, placed in the slot indicated by the aIndex parameter. */
		KStoreEntryAdded =0x00000008,
	/** The store has deleted the entry that was in the slot indicated by the aIndex 
	parameter. */
		KStoreEntryDeleted =0x00000010,
	/** The store has changed the entry that was in the slot indicated by the aIndex 
	parameter. */
		KStoreEntryChanged =0x00000020,
	/** The store contents have substantially changed and the TSY is recommending that 
	the client performs a refresh by reading all the contents again. */
		KStoreDoRefresh =0x00000040
		};

	IMPORT_C void NotifyStoreEvent(TRequestStatus& aReqStatus, TUint32& aEvent, TInt& aIndex) const;

protected:
	CMobilePhoneStorePtrHolder* iStorePtrHolder;

protected:
	RMobilePhoneStore();
	IMPORT_C void BaseConstruct(CMobilePhoneStorePtrHolder* aPtrHolder);
	IMPORT_C void Destruct();
	};


/*********************************************************/
//
// Call based functionality (RMobileCall)
// 
/*********************************************************/



class CMobileCallPtrHolder;

class RMobileCall : public RCall
/** Provides access to the functionality associated with a specific mobile call.

RMobileCall encapsulates access to a mobile phone. The functionality of RMobileCall 
is divided into a number of functional units, for the purpose of easier documentation 
and navigation and selectable support by TSY. 

Note: Some RMobileCall function members must be supported by the TSY while 
others are part of optional "functional unit" and only need to be supported
if the TSY supports that functional unit. When a functional unit is mandatory 
then the TSY should at least support the Get...Caps() member function to indicate 
the member functions that are supported for this unit. 
 */
	{
public:
	IMPORT_C RMobileCall();
	/***********************************************************************************/
	//
	//  Mobile call parameters - used within Dial/Answer API
	//
	/***********************************************************************************/

	// used to set iExtensionId in RCall::TCallParams
/** The mobile call parameter extension IDs.

Modes: Common */
	enum TMobileCallParamsExtensionId
		{
	/** The iExtensionId contents indicate that the packaged class is a TMobileCallParamsV1. */
		KETelMobileCallParamsV1=KETelExtMultimodeV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileDataCallParamsV1.
	
	Modes: Common */
		KETelMobileDataCallParamsV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileHscsdCallParamsV1.
	
	Modes: GSM/WCDMA */
		KETelMobileHscsdCallParamsV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileCallParamsV2.
	
	Modes: Common */
		KETelMobileCallParamsV2=KETelExtMultimodeV2,
	/** The iExtensionId contents indicate that the packaged class is a TMobileDataCallParamsV2.
	
	Modes: Common */
		KETelMobileDataCallParamsV2,
	/** The iExtensionId contents indicate that the packaged class is a TMobileHscsdCallParamsV2.

	Modes: GSM/WCDMA */
		KETelMobileHscsdCallParamsV2,
	/** The iExtensionId contents indicate that the packaged class is a TEtel3rdPartyMobileCallParamsV1. 
	
	Modes: Common */	
		KETel3rdPartyCallParamsV1=KETelExt3rdPartyV1
		};

/** Caller Id restriction settings.

Modes: Common

@see TMobileCallParamsV1 */
	enum TMobileCallIdRestriction
		{
	/** The default setting should be used if the user has not explicitly requested 
	their identity to be restricted/allowed. */
		EIdRestrictDefault,
	/** The user has explicitly requested their identity to be sent for this call. */
		ESendMyId,
	/** The user has explicitly requested their identity not to be sent for this call. */
		EDontSendMyId
		};

	class TMobileCallCugV1 : public RMobilePhone::TMultimodeType
/** This class is used to set up a CUG (Closed User Group) call. 

TMobileCallCugV1() is valid in GSM/WCDMA mode only. The client application 
should set the CUG settings for the call depending on the user's choice. If
the user has not explicitly requested a CUG call then this parameter should 
indicate that explicit CUG invoke is false. The TSY ignores this parameter 
if in CDMA mode. 
*/
		{
	public:
		IMPORT_C TMobileCallCugV1();
	public:
	/** A boolean indicating whether Closed User Group is being explicitly invoked by 
	the client or not. If this parameter is false, the other entries in this structure 
	will be ignored. */
		TBool	iExplicitInvoke;
	/** The Closed User Group index that the user has specified for this call (if no
	index has been specified then this element will equal -1). */
		TInt	iCugIndex;
	/** A boolean indicating whether the user has suppressed their Outgoing Access option 
	or not. */
		TBool	iSuppressOA;
	/** A boolean indicating whether the user has suppressed the use of their preferential 
	Closed User Group or not. */
		TBool	iSuppressPrefCug;
		};
	
/** Multicall Operation set-up.

Mode: WCDMA */
	enum TMobileCallMulticallBearerMode
		{
	/** Multicall is not supported. */
		EMulticallNotSupported,
	/** MS will accept incoming call and establish a connection using an existing bearer. */
		EMulticallShareBearer,
	/** MS will accept incoming call and establish a connection by creating a new bearer. */
		EMulticallNewBearer
		};

	

	class TMobileCallParamsV1 : public RCall::TCallParams
/** Defines the parameters used for set-up of a call of any type. 
*/
		{
	public:
		IMPORT_C TMobileCallParamsV1();
	public:
	/** Call Id restriction setting to be used for this call.

	@see TMobileCallIdRestriction */
		TMobileCallIdRestriction iIdRestrict;
	/** Closed User Group setting to be used for this call.
	
	@see TMobileCallCugV1 */
		TMobileCallCugV1 iCug;
	/** Specifies whether this call attempt is user initiated (EFalse) or a client initiated 
	redial (ETrue). */
		TBool iAutoRedial;
		};

/** A typedef'd packaged TMobileCallParamsV1 for passing through a generic API function 
member. */
	typedef TPckg<TMobileCallParamsV1> TMobileCallParamsV1Pckg;

	
 
 	class TMobileCallParamsV2 : public TMobileCallParamsV1
/** Defines the parameters used for set-up of a call of any type 
for version v2.0 of the API.
A new parameter (iBearerMode) is required to support Multicall.
@publishedPartner
@released 
*/
 		{
 	public:
 		IMPORT_C TMobileCallParamsV2();
 	public:
	/** The bearer mode. */
 		TMobileCallMulticallBearerMode iBearerMode;
 		};
 
/** A typedef'd packaged TMobileCallParamsV1 for passing through a generic API 
function member. */
 	typedef TPckg<TMobileCallParamsV2> TMobileCallParamsV2Pckg;
 
	/***********************************************************************************/
	//
	// Mobile Call Data Functional Unit
	//
	/***********************************************************************************/

/** In GSM mode, maps to list of supported speeds returned in response to AT+CBST=?. 
In CDMA mode, maps to data rates supported by supported service options.

@see TMobileCallDataCapsV1 */
	enum TMobileCallDataSpeedCaps
		{
	/** Call can support autobauding. */
		KCapsSpeedAutobauding = 0x00000001,
	/** Call can support a speed of 2400bps. */
		KCapsSpeed2400  = 0x00000002,
	/** Call can support a speed of 4800bps. */
		KCapsSpeed4800  = 0x00000004,
	/** Call can support a speed of 9600bps. */
		KCapsSpeed9600  = 0x00000008,
	/** Call can support a speed of 14400bps. */
		KCapsSpeed14400 = 0x00000010,
	/** Call can support a speed of 19200bps. */
		KCapsSpeed19200 = 0x00000020,
	/** Call can support a speed of 28800bps. */
		KCapsSpeed28800 = 0x00000040,
	/** Call can support a speed of 32000bps. */
		KCapsSpeed32000 = 0x00000080,
	/** Call can support a speed of 33600bps. */
		KCapsSpeed33600 = 0x00000100,
	/** Call can support a speed of 38400bps. */
		KCapsSpeed38400 = 0x00000200,
	/** Call can support a speed of 43200bps. */
		KCapsSpeed43200 = 0x00000400,
	/** Call can support a speed of 48000bps. */
		KCapsSpeed48000 = 0x00000800,
	/** Call can support a speed of 56000bps. */
		KCapsSpeed56000 = 0x00001000,
	/** Call can support a speed of 57600bps. */
		KCapsSpeed57600 = 0x00002000,
	/** Call can support a speed of 64000bps. */
		KCapsSpeed64000 = 0x00004000,
	/** Call can support extended data speed capabilities. This flag is reserved for 
	future expansion of API and should always be set to zero. */
		KCapsSpeedExtended = 0x80000000		
		};

/** List of supported values of the <speed> parameter returned in response to AT+CBST=?

Not applicable to CDMA mode

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataProtocolCaps
		{
	/** Call can support V.22bis standard
	
	Modes: COMMON */
		KCapsProtocolV22bis = 0x00000001,
	/** Call can support V.32 standard.
	
	Modes: COMMON */
		KCapsProtocolV32 = 0x00000002,
	/** Call can support V.34 standard.
	
	Modes: COMMON */
		KCapsProtocolV34 = 0x00000004,
	/** Call can support V.110 standard.
	
	Modes: GSM/WCDMA */
		KCapsProtocolV110 = 0x00000008,
	/** Call can support V.120 standard.
	
	Modes: GSM/WCDMA */
		KCapsProtocolV120 = 0x00000010,
	/** Call can support bit transparent service.
	
	Modes: GSM/WCDMA */
		KCapsProtocolBitTransparent = 0x00000020,
	/** Call can support X31 flag stuffing standard.
	
	Modes: GSM/WCDMA */
		KCapsProtocolX31FlagStuffing = 0x00000040,
	/** Call can support both PIAF standards (32000bps and 64000bps).
	
	Modes: GSM/WCDMA */
		KCapsProtocolPIAFS = 0x00000080,
	/** Call can support request for Multimedia protocol (3G-324M) over a call to PSTN
	with voice fallback.
	
	Modes: WCDMA */
		KCapsPstnMultimediaVoiceFallback = 0x00000100,
	/** Call can support request for Multimedia protocol (3G-324M) over a call to PSTN
	without voice fallback
	
	Modes: WCDMA */
		KCapsPstnMultimedia = 0x00000200,
	/** Call can support request for Multimedia protocol (3G-324M) over a call to ISDN 
	(voice fallback not possible).
	
	Modes: WCDMA */
		KCapsIsdnMultimedia = 0x00000400,
	/** Call can support extended data carrier capabilities. This flag is reserved for 
	future expansion and should always be set to zero for v1.0 of this API.
	
	Modes: COMMON */
		KCapsProtocolExtended = 0x80000000
		};

/** In GSM mode, maps to list of supported <name> returned in response to AT+CBST=? 
In CDMA mode, maps to supported service options.

Modes: COMMON

@see TMobileCallDataCapsV1 */
	enum TMobileCallDataServiceCaps
		{
		KCapsDataCircuitAsynchronous = 0x00000001,
		KCapsDataCircuitAsynchronousRDI = 0x00000002,
		KCapsDataCircuitSynchronous = 0x00000004,
		KCapsDataCircuitSynchronousRDI = 0x00000008,
	/** Call can support "PAD Access (asynchronous) (UDI)".
	
	Modes: GSM/WCDMA */
		KCapsPADAsyncUDI = 0x00000010,
	/** Call can support "PAD Access (asynchronous) (RDI)"

	Modes: GSM/WCDMA */
		KCapsPADAsyncRDI = 0x00000020,
	/** Call can support "Packet Access (synchronous) (UDI)" 
	
	Modes: GSM/WCDMA */
		KCapsPacketAccessSyncUDI = 0x00000040,
	/** Call can support "Packet Access (synchronous) (RDI)".

	Modes: GSM/WCDMA */
		KCapsPacketAccessSyncRDI = 0x00000080,
	/** Call can support extended data service capabilities. This flag is reserved for 
	future expansion of this API and should always be set to zero for v1.0 of 
	this API.
	
	Modes: COMMON */
		KCapsServiceExtended = 0x80000000
		};

/** Maps to list of supported <ce> returned in response to AT+CBST=?

Not applicable to CDMA mode.

@see TMobileCallDataCapsV1 */
	enum TMobileCallDataQoSCaps
		{
	/** Call can support a request for "transparent only" connection. */
		KCapsTransparent = 0x00000001,
	/** Call can support a request for "non-transparent only" connection. */
		KCapsNonTransparent = 0x00000002,
	/** Call can support a request for "transparent preferred" connection. */
		KCapsTransparentPreferred = 0x00000004,
	/** Call can support a request for "non-transparent preferred" connection. */
		KCapsNonTransparentPreferred = 0x00000008
		};

/** Supported Air Interface User Rates. */
	enum TMobileCallAiurCodingCaps
		{
	/** Air interface user rate of 4.8k is supported. */
		KCapsAiurCoding48 = 0x01,
	/** Air interface user rate of 9.6k is supported. */
		KCapsAiurCoding96 = 0x04,
	/** Air interface user rate of 14.4k is supported. */
		KCapsAiurCoding144 = 0x08
		};

/** HSCSD coding capabilities.

Modes: GSM/WCDMA */
	enum TMobileCallTchCodingsCaps
		{
	/** Call supports HSCSD coding on 4.8K full rate data traffic channel. */
		KCapsTchCoding48  = 0x00000001,
	/** Call supports HSCSD coding on 9.6K full rate data traffic channel. */
		KCapsTchCoding96  = 0x00000004,
	/** Call supports HSCSD coding on 14.4K full rate data traffic channel. */
		KCapsTchCoding144 = 0x00000008,
	/** Call supports HSCSD coding on 28.8K full rate data traffic channel (only possible 
	when 14.4K is supported). */
		KCapsTchCoding288 = 0x00000010,
	/** Call supports HSCSD coding on 32.0K full rate data traffic channel (only possible 
	in a two-timeslot configuration). */
		KCapsTchCoding320 = 0x00000020,
	/** Call supports HSCSD coding on 43.2K full rate data traffic channel (only possible 
	when 14.4K is supported). */
		KCapsTchCoding432 = 0x00000040
		};

/** The call asymmetry capabilities.

Modes: GSM/WCDMA

@see TMobileCallDataCapsV1 */
	enum TMobileCallAsymmetryCaps
		{
	/** Call supports "No Preference" option for asymmetry bias of a Non-Transparent
	ECSD call. */
		KCapsAsymmetryNoPreference= 0x00000001,
	/** Call supports "Downlink bias" option for asymmetry bias of a Non-Transparent 
	ECSD call. 
	
	This means 8-PSK modulation is preferred downlink and GMSK modulation uplink. */
		KCapsAsymmetryDownlink = 0x00000002,
	/** Call supports "Uplink bias" option for asymmetry bias of a Non-Transparent ECSD 
	call. 
	
	This means 8-PSK modulation is preferred uplink and GMSK modulation downlink. */
		KCapsAsymmetryUplink = 0x00000004
		};

/** The supported Call RLP versions.

Modes: GSM/WCDMA

@see TMobileCallDataCapsV1 */
	enum TMobileCallRLPVersionCaps
		{
	/** Call supports the single link, basic RLP version 0. */
		KCapsRLPSingleLinkVersion0 = 0x00000001,
	/** Call supports the single link, extended RLP version 1. */
		KCapsRLPSingleLinkVersion1 = 0x00000002,
	/** Call supports the multi link, RLP version 2. */
		KCapsRLPMultiLinkVersion2  = 0x00000004
		};

/** The supported V42bis options.

Modes: GSM/WCDMA

@see TMobileCallDataCapsV1 */
	enum TMobileCallV42bisCaps
		{
	/** Call supports V42bis compression in initiator-responder direction. */
		KCapsV42bisTxDirection = 0x00000001,
	/** Call supports V42bis compression in responder-initiator direction. */
		KCapsV42bisRxDirection = 0x00000002,
	/** Call supports V42bis compression in both directions. */
		KCapsV42bisBothDirections = 0x00000004
		};

	

	class TMobileCallDataCapsV1 : public RMobilePhone::TMultimodeType
	/** Defines the capabilities of a circuit switched data call. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileCallDataCapsV1();
	public:
	/** Data speed capabilities - a bit wise sum of the caps defined in TMobileCallDataSpeedCaps. */
		TUint32	iSpeedCaps;
	/** Data protocol capabilities - a bit wise sum of the caps defined in TMobileCallDataProtocolCaps. */
		TUint32	iProtocolCaps;
	/** Data service capabilities - a bit wise sum of the caps defined in TMobileCallDataServiceCaps. */
		TUint32	iServiceCaps;
	/** Data QoS capabilities - a bit wise sum of the caps defined in TMobileCallDataQoSCaps.
	
	Note: Only available in GSM/WCDMA mode. */
		TUint32	iQoSCaps;
	/** A boolean indicating whether or not the MS supports HSCSD for this call. If 
	this attribute equals EFalse all the following attributes are invalid.

	Note: Only available in GSM/WCDMA mode. */
		TBool	iHscsdSupport;
	/** For HSCSD: The multi-slot class supported. */
		TInt	iMClass;
	/** For HSCSD: The maximum supported number of time-slots in the receive (down-link) 
	direction. */
		TInt	iMaxRxTimeSlots;
	/** For HSCSD: The maximum supported number of time-slots in the transmit (up-link) 
	direction. */
		TInt	iMaxTxTimeSlots;
	/** For HSCSD: The maximum supported total number of receive and transmit time-slots 
	that can be used at same time. */
		TInt	iTotalRxTxTimeSlots;
	/** For HSCSD: A bit-wise sum of the supported air interface channel codings defined 
	in TMobileCallAiurCodingCaps. */
		TUint32	iCodingCaps;
	/** For HSCSD: A bit-wise sum of the supported asymmetry bias defined in TMobileCallAsymmetryCaps. */
		TUint32 iAsymmetryCaps;
	/** For HSCSD: A boolean indicating whether or not the MS supports automatic user 
	initiated service level upgrading. */
		TBool 	iUserInitUpgrade;
	/** For HSCSD and CSD: A bit-wise sum of the supported Radio Link Protocol versions 
	defined in TMobileCallRLPVersionCaps. */
		TUint32	iRLPVersionCaps;
	/** For HSCSD and CSD: A bit-wise sum of the supported V42bis compression capabilities 
	defined in TMobileCallV42bisCaps . */
		TUint32	iV42bisCaps;
		};

/** A typedef'd packaged TMobileCallDataCapsV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileCallDataCapsV1> TMobileCallDataCapsV1Pckg;

	IMPORT_C TInt GetMobileDataCallCaps(TDes8& aCaps) const;
	IMPORT_C void NotifyMobileDataCallCapsChange(TRequestStatus& aReqStatus, TDes8& aCaps) const;

/** The call setup requested data speed.

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataSpeed
		{
	/** Call set-up will request speed depending on data carrier chosen. */
		ESpeedUnspecified,
	/** Call set-up will request autobauding. */
		ESpeedAutobauding,
	/** Call set-up will request 2400bps. */
		ESpeed2400,
	/** Call set-up will request 4800bps. */
		ESpeed4800,
	/** Call set-up will request 9600bps. */
		ESpeed9600,
	/** Call set-up will request 14400bps. */
		ESpeed14400,
	/** Call set-up will request 19200bps. */
		ESpeed19200,
	/** Call set-up will request 28800bps. */
		ESpeed28800,
	/** Call set-up will request 32000bps. */
		ESpeed32000,
	/** Call set-up will request 33600bps. */
		ESpeed33600,
	/** Call set-up will request 38400bps. */
		ESpeed38400,
	/** Call set-up will request 43200bps. */
		ESpeed43200,
	/** Call set-up will request 48000bps. */
		ESpeed48000,
	/** Call set-up will request 56000bps. */
		ESpeed56000,
	/** Call set-up will request 57600bps. */
		ESpeed57600,
	/** Call set-up will request 64000bps. */
		ESpeed64000
		};

/** The call set-up requested data protocol.

Modes: GSM/WCDMA */
	enum TMobileCallDataProtocol
		{
	/** Call set-up will request carrier depending on data speed chosen. */
		EProtocolUnspecified,
	/** Call set-up will request the V.22bis standard. */
		EProtocolV22bis,
	/** Call set-up will request the V.32 standard. */
		EProtocolV32,
	/** Call set-up will request the V.34 standard. */
		EProtocolV34,
	/** Call set-up will request the V.110 standard. */
		EProtocolV110,
	/** Call set-up will request the V.120 standard. */
		EProtocolV120,
	/** Call set-up will request the X31FlagStuffing standard. */
		EProtocolX31FlagStuffing,
	/** Call set-up will request the PIAFS standard. */
		EProtocolPIAFS,
	/** Call set-up will request the bit transparent service. */
		EProtocolBitTransparent,
	/** Call set-up will request a PSTN multimedia call with voice fallback if multimedia 
	fails.
	
	WCDMA mode only. */
		EProtocolPstnMultimediaVoiceFallback,
	/** Call set-up will request a PSTN multimedia call.
	
	WCDMA mode only. */
		EProtocolPstnMultimedia,
	/** Call set-up will request a ISDN multimedia call.
	
	WCDMA mode only. */
		EProtocolIsdnMultimedia
		};

/** The call setup requested data services.

Modes: Common

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataService
		{
	/** Call set-up will request its default service type.
	
	Modes: Common */
		EServiceUnspecified,
	/** Call set-up will request:
	
	GSM mode - Data circuit asynchronous (UDI or 3.1 KHz, ex PLMN) service 

	In CDMA mode - Async Data service 
	
	Modes: Common */
		EServiceDataCircuitAsync,
	/** Call set-up will request Data circuit asynchronous (RDI) service.
	
	Modes: GSM/WCDMA */
		EServiceDataCircuitAsyncRdi,
	/** Call set-up will request Data circuit synchronous (UDI or 3.1 KHz, ex PLMN) 
	service.
	
	Modes: GSM/WCDMA */
		EServiceDataCircuitSync,
	/** Call set-up will request Data circuit synchronous (RDI) service.
	
	Modes: GSM/WCDMA */
		EServiceDataCircuitSyncRdi,
	/** Call set-up will request PAD asynchronous (UDI) service.
	
	Modes: GSM/WCDMA */
		EServicePADAsyncUDI,
	/** Call set-up will request PAD asynchronous (RDI) service.
	
	Modes: GSM/WCDMA */
		EServicePADAsyncRDI,
	/** Call set-up will request Packet Access synchronous (UDI) service.
	
	Modes: GSM/WCDMA */
		EServicePacketAccessSyncUDI,
	/** Call set-up will request Packet Access synchronous (RDI) service.
	
	Modes: GSM/WCDMA */
		EServicePacketAccessSyncRDI
		};

/** The call set-up requested quality of service (QoS).

Modes: GSM/WCDMA

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataQoS
		{
	/** Call set-up will request its default connection. */
		EQoSUnspecified,
	/** Call set-up will request a transparent connection. */
		EQoSTransparent,
	/** Call set-up will request a non-transparent connection. */
		EQoSNonTransparent,
	/** Call set-up will prefer a transparent connection. */
		EQosTransparentPreferred,
	/** Call set-up will prefer a non-transparent connection. */
		EQosNonTransparentPreferred
		};

/** The call set-up requested RLP version.

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataRLPVersion
		{
	/** Call set-up will request no RLP version. */
		ERLPNotRequested,
	/** Call set-up will request single link basic RLP (version 0). */
		ERLPSingleLinkVersion0,
	/** Call set-up will request single link extended RLP (version 1). */
		ERLPSingleLinkVersion1,
	/** Call set-up will prefer multi link RLP (version 2). */
		ERLPMultiLinkVersion2
		};

/** The V.42bis parameters used in the call set-up of a V.42bis data call.

@see TMobileDataCallParamsV1 */
	enum TMobileCallDataV42bis
		{
	/** Call set-up will not request V.42bis compression. */
		EV42bisNeitherDirection,
	/** Call set-up will request V.42bis compression in initiator-responder direction 
	only. */
		EV42bisTxDirection,
	/** Call set-up will request V.42bis compression in responder-initiator direction 
	only. */
		EV42bisRxDirection,
	/** Call set-up will request V.42bis compression in both directions. */
		EV42bisBothDirections
		};

	
	

	class TMobileDataCallParamsV1 : public TMobileCallParamsV1
/** Defines the parameters used for setup of a circuit switched data call. 
*/
		{
	public:
		IMPORT_C TMobileDataCallParamsV1();
	public:
	/** The type of data service.
	
	@see TMobileCallDataService */
		TMobileCallDataService iService;
	/** The data transfer rate.

	@see TMobileCallDataSpeed */
		TMobileCallDataSpeed iSpeed;
	/** The ITU-T standard modulation protocol or higher application protocol. */
		TMobileCallDataProtocol iProtocol;
	/** The quality of data service.
	
	@see TMobileCallDataQoS */
		TMobileCallDataQoS iQoS;
	/** The version of Radio Link Protocol.
	
	Modes: GSM/WCDMA
	
	@see TMobileCallDataRLPVersion */
		TMobileCallDataRLPVersion iRLPVersion;
	/** The IWF to MS windows size.
	
	Modes: GSM/WCDMA */
		TInt iModemToMSWindowSize;
	/** The MS window to IWF size.
	
	Modes: GSM/WCDMA */
		TInt iMSToModemWindowSize;
	/** The acknowledgement timer.
	
	Modes: GSM/WCDMA */
		TInt iAckTimer;
	/** The number of retransmission attempts.
	
	Modes: GSM/WCDMA */
		TInt iRetransmissionAttempts;
	/** The resequencing period in integer format.
	
	Modes: GSM/WCDMA */
		TInt iResequencingPeriod;
	/** The V42bis compression request parameter.
	
	@see TMobileCallDataV42bis */
		TMobileCallDataV42bis iV42bisReq;
	/** The number of codewords in the algorithm. */
		TInt iV42bisCodewordsNum;
	/** The maximum encodable data string length. */
		TInt iV42bisMaxStringLength;
		TBool iUseEdge; // True for ECSD
		};

/** A typedef'd packaged TMobileDataCallParamsV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileDataCallParamsV1> TMobileDataCallParamsV1Pckg;

	
	

	class TMobileDataCallParamsV2 : public TMobileDataCallParamsV1
/** Defines the parameters used for setup of a circuit switched data call for version 
v2.0 of the API. 
*/
		{
	public:
		IMPORT_C TMobileDataCallParamsV2();
	public:
	/** The bearer mode. */
		TMobileCallMulticallBearerMode iBearerMode;
		};

/** A typedef'd packaged TMobileDataCallParamsV2 for passing through a generic 
API function member. */
	typedef TPckg<TMobileDataCallParamsV2> TMobileDataCallParamsV2Pckg;

/** The Air interface user rate.

Modes: GSM/WCDMA. */
	enum TMobileCallAiur
		{
	/** Air interface user rate is not set. */
		EAiurBpsUnspecified,
	/** Air interface user rate of 9.6Kbps. */
		EAiurBps9600,
	/** Air interface user rate of 14.4Kbps. */
		EAiurBps14400,
	/** Air interface user rate of 19.2Kbps. */
		EAiurBps19200,
	/** Air interface user rate of 28.8Kbps. */
		EAiurBps28800,
	/** Air interface user rate of 38.4Kbps. */
		EAiurBps38400,
	/** Air interface user rate of 43.2Kbps. */
		EAiurBps43200,
	/** Air interface user rate of 57.6Kbps. */
		EAiurBps57600
		};

/** Call Asymmetry preferences.

Modes: GSM/WCDMA

@see TMobileHscsdCallParamsV1 */
	enum TMobileCallAsymmetry
		{
	/** There is no preference for Asymmetry Bias. */
		EAsymmetryNoPreference,
	/** Downlink Bias is preferred. */
		EAsymmetryDownlink,
	/** Uplink Bias is preferred. */
		EAsymmetryUplink
		};

/** The call channel coding used.

Modes: GSM/WCDMA */
	enum TMobileCallTchCoding
		{
	/** Channel coding is unspecified. */
		ETchCodingUnspecified,
	/** 4.8K full rate data traffic channel is used. */
		ETchCoding48,
	/** 9.6K full rate data traffic channel is used. */
		ETchCoding96,
	/** 14.4K full rate data traffic channel is used. */
		ETchCoding144,
	/** 28.8K full rate data traffic channel is used. */
		ETchCoding288,
	/** 32.0K full rate data traffic channel is used. */
		ETchCoding320,
	/** 43.2K full rate data traffic channel is used. */
		ETchCoding432
		};

	

	class TMobileDataRLPRangesV1 : public RMobilePhone::TMultimodeType
/** Defines the parameters for minimum and maximum RLP parameter ranges.

Modes: GSM/WCDMA 

*/
		{
	public:
		IMPORT_C TMobileDataRLPRangesV1();
	public:
	/** Maximum modem to MS window size value. */
		TInt  iIWSMax;
	/** Minimum modem to MS window size value. */
		TInt  iIWSMin;
	/** Maximum MS to modem window size value. */
		TInt  iMWSMax;
	/** Minimum MS to modem window size value. */
		TInt  iMWSMin;
	/** Maximum acknowledgement timer value. */
		TInt  iT1Max;
	/** Minimum acknowledgement timer value. */
		TInt  iT1Min;
	/** Maximum retransmission attempts value. */
		TInt  iN2Max;
	/** Minimum retransmission attempts value. */
		TInt  iN2Min;
	/** Maximum resequencing period value. */
		TInt  iT4Max;
	/** Minimum resequencing period value. */
		TInt  iT4Min;
		};

/** A typedef'd packaged TMobileDataRLPRangesV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileDataRLPRangesV1> TMobileDataRLPRangesV1Pckg;

	IMPORT_C void GetMobileDataCallRLPRange(TRequestStatus& aReqStatus, TInt aRLPVersion, TDes8& aRLPRange) const;
	
	class TMobileHscsdCallParamsV1 : public TMobileDataCallParamsV1
/** The High Speed Circuit Switched Data parameters. 
*/
		{
	public:
		IMPORT_C TMobileHscsdCallParamsV1();
	public:
	/** The wanted Air Interface Rate for the HSCSD call being set-up.
	
	Modes: GSM/WCDMA

	@see TMobileCallAiur */
		TMobileCallAiur	iWantedAiur;
	/** The wanted number of receive timeslots for the HSCSD call being set-up.
	
	Modes: GSM/WCDMA */
		TInt iWantedRxTimeSlots;
		TInt iMaxTimeSlots;
	/** Bit-wise sum of acceptable air interface channel codings TMobileCallAiurCodingCaps 
	for the HSCSD call being set-up.
	
	Modes: GSM/WCDMA */
		TUint iCodings;
	/** The wanted asymmetry bias for the HSCSD call being set-up.
	
	Modes: GSM/WCDMA
	
	@see TMobileCallAsymmetry */
		TMobileCallAsymmetry  iAsymmetry;
	/** A boolean indicating whether or not automatic user initiated service level upgrading 
	is active for the HSCSD call being set-up. ETrue means enabled, EFalse means 
	disabled.
	
	Modes: GSM/WCDMA */
		TBool iUserInitUpgrade;
		};

/** A typedef'd packaged TMobileHscsdCallParamsV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobileHscsdCallParamsV1> TMobileHscsdCallParamsV1Pckg;

	class TMobileHscsdCallParamsV2 : public TMobileHscsdCallParamsV1
/** Call parameters for High Speed Circuit Switched Data (HSCSD) for version v2.0 
of the API. 

*/
		{
	public:
		IMPORT_C TMobileHscsdCallParamsV2();
	public:
	/** The bearer mode. */
		TMobileCallMulticallBearerMode iBearerMode;
		};

/** A typedef'd packaged TMobileHscsdCallParamsV2 for passing through a generic 
API function member. */
	typedef TPckg<TMobileHscsdCallParamsV2> TMobileHscsdCallParamsV2Pckg;

	IMPORT_C void SetDynamicHscsdParams(TRequestStatus& aReqStatus, TMobileCallAiur aAiur, TInt aRxTimeslots) const;

	class TMobileCallHscsdInfoV1 : public RMobilePhone::TMultimodeType
/** The HSCSD settings.

Modes: GSM/WCDMA 

*/
		{
	public:
		IMPORT_C TMobileCallHscsdInfoV1();
	public:
	/** Current AIUR for the HSCSD call.
	
	@see TMobileCallAiur */
		TMobileCallAiur	iAiur;
	/** Current number of receive timeslots for the HSCSD call. */
		TInt iRxTimeSlots;
	/** Current number of transmit time slots for the HSCSD call. */
		TInt iTxTimeSlots;
	/** Current channel coding for the HSCSD call. */
		TMobileCallTchCoding iCodings;
		};

/** A typedef'd packaged TMobileCallHscsdInfoV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileCallHscsdInfoV1> TMobileCallHscsdInfoV1Pckg;

	IMPORT_C TInt GetCurrentHscsdInfo(TDes8& aHSCSDInfo) const;
	IMPORT_C void NotifyHscsdInfoChange(TRequestStatus& aReqStatus, TDes8& aHSCSDInfo) const;

	/***********************************************************************************/
	//
	// Multimedia Calls
	//
	/***********************************************************************************/

	IMPORT_C void AnswerMultimediaCallAsVoice(TRequestStatus& aReqStatus, const TDesC8& aCallParams, TName& aCallName) const;
	IMPORT_C void NotifyVoiceFallback(TRequestStatus& aReqStatus, TName& aCallName) const;

	//
	// Mobile Alternating Call Functional Unit
	//

	IMPORT_C void SwitchAlternatingCall(TRequestStatus& aReqStatus) const;
	IMPORT_C void NotifyAlternatingCallSwitch(TRequestStatus& aReqStatus) const;

	/***********************************************************************************/
	//
	// MobileCallControl functional unit
	//
	/***********************************************************************************/

/** Mobile call control capabilites.

Modes: Common */
	enum TMobileCallControlCaps 
		{
		//KCapsData=0x00000001, // taken from etel.h
		//KCapsFax=0x00000002,
		//KCapsVoice=0x00000004,
		//KCapsDial=0x00000008,
		//KCapsConnect=0x00000010,
		//KCapsHangUp=0x00000020,
		//KCapsAnswer=0x00000040,
		//KCapsLoanDataPort=0x00000080, 
		//KCapsRecoverDataPort=0x00000100
	/** Indicates that this call can be put on hold. This implies that the call is currently 
	active and that there is no other held call. */
		KCapsHold = 0x00000200,
	/** Indicates that this call can be resumed. This implies that the call is currently 
	on hold and that there is no other active call. 
	
	Modes: Common */
		KCapsResume = 0x00000400,
	/** Indicates that this call's state can be swapped to the opposite state. This
	implies that this call is either active or held. There may be another call 
	in the opposite state and if this is the case then both calls will be simultaneously 
	swapped to their opposite state. 
	
	Modes: Common */
		KCapsSwap = 0x00000800,
	/** Indicates that this incoming call can be deflected to another destination. 
	
	Modes: GSM/WCDMA */
		KCapsDeflect = 0x00001000,
	/** Indicates that this call can be transferred to the remote party of another call. 
	For this capability to be set there must be one active call and one held or 
	dialing call.
	
	Modes: GSM/WCDMA */
		KCapsTransfer = 0x00002000,
	/** Indicates that this call can be joined either to another single call to form 
	a conference call or to an existing conference call.
	
	Modes: Common */
		KCapsJoin = 0x00004000,
	/** Indicates that this call (within a conference call) can go into One to One mode. 
	This action would put the rest of the conference call on hold. 
	
	Modes: GSM/WCDMA */
		KCapsOneToOne = 0x00008000,
	/** Indicates that the user can activate a CCBS request on this failed call set-up. 
	
	Modes: GSM/WCDMA */
		KCapsActivateCCBS = 0x00010000,
	/** Indicates that this call is part of an alternating call and the client can call 
	SwitchAlternatingCall() on this call in order to switch it to its other mode.
	
	Modes: GSM/WCDMA */
		KCapsSwitchAlternatingCall = 0x00020000,
	/** Indicates that this call can use/create a new bearer. This means that multiple 
	calls (multicall) can be active at the same time using no more that 7 bearers 
	simultaneously. The other option is to swap with an active call, therefore 
	it becomes held and shares the same bearer.
	
	Modes: WCDMA */
		KCapsMulticall = 0x00040000
		};


/** Mobile call events capabilities.

Modes: Common */
	enum TMobileCallEventCaps
		{
	/** Indicates that local hold notifications are supported.
	
	Modes: Common */
		KCapsLocalHold = 0x00000001,
	/** Indicates that local resume notifications are supported. 
	
	Modes: Common */
		KCapsLocalResume = 0x00000002,
	/** Indicates that local deflect transfer notifications are supported. 
	
	Modes: GSM/WCDMA */
		KCapsLocalDeflectCall = 0x00000004,
	/** Indicates that local explicit transfer notifications are supported. 
	
	Modes: GSM/WCDMA */
		KCapsLocalTransfer = 0x00000008,
	/** Indicates that remote hold notifications are supported. 

	Modes: GSM/WCDMA */
		KCapsRemoteHold = 0x00000010,
	/** Indicates that remote resume notifications are supported. 
	
	Modes: GSM/WCDMA */
		KCapsRemoteResume = 0x00000020,
	/** Indicates that remote termination notifications are supported. 
	
	Modes: Common */
		KCapsRemoteTerminate = 0x00000040,
	/** Indicates that remote conference invocation notifications are supported.
	
	Modes: GSM/WCDMA */
		KCapsRemoteConferenceCreate = 0x00000080
		};

	

	class TMobileCallCapsV1 : public RMobilePhone::TMultimodeType
/** Defines the dynamic capabilities of a mobile call. 
*/
		{
	public:
		IMPORT_C TMobileCallCapsV1();
	public:
	/** Call control capability information - a bit wise sum of TMobileCallControlCaps 
	constants */
		TUint32 iCallControlCaps;
	/** Call event capability information - a bit wise sum of TMobileCallEventCaps constants. */
		TUint32 iCallEventCaps;
		};

/** A typedef'd packaged TMobileCallCapsV1 for passing through a generic API function 
member. */
	typedef TPckg<TMobileCallCapsV1> TMobileCallCapsV1Pckg;

	IMPORT_C TInt GetMobileCallCaps(TDes8& aCaps) const;
	IMPORT_C void NotifyMobileCallCapsChange(TRequestStatus& aReqStatus, TDes8& aCaps) const;

	IMPORT_C void Hold(TRequestStatus& aReqStatus) const;
	IMPORT_C void Resume(TRequestStatus& aReqStatus) const;
	IMPORT_C void Swap(TRequestStatus& aReqStatus) const;
	IMPORT_C void DialISV(TRequestStatus& aStatus,const TDesC8& aCallParams,const TTelNumberC& aTelNumber);
	IMPORT_C void AnswerIncomingCallISV(TRequestStatus& aStatus,const TDesC8& aCallParams);

/** The type of call deflection requested.

@see Deflect() */
	enum TMobileCallDeflect
		{
	/** Destination is not specified. */
		EDeflectUnspecified,
	/** Call will be deflected to voicemail. */
		EDeflectVoicemail,
	/** Call will be deflected to the pre-registered number for the call forwarding 
	service. */
		EDeflectRegisteredNumber,
	/** Call will be deflected to the number supplied in the aDestination parameter. */
		EDeflectSuppliedNumber
		};

	IMPORT_C void Deflect(TRequestStatus& aReqStatus, TMobileCallDeflect aDeflectType, const RMobilePhone::TMobileAddress& aDestination) const;
	IMPORT_C void Transfer(TRequestStatus& aReqStatus) const;
	IMPORT_C void GoOneToOne(TRequestStatus& aReqStatus) const;

/** The mobile call events.

Modes: Common */
	enum TMobileCallEvent
		{
	/** The call has been placed on hold as a result of a local action. 
	
	Modes: Common */
		ELocalHold,
	/** The call has been resumed as a result of a local action. 
	
	Modes: Common */
		ELocalResume,
	/** The call has been deflected to another remote party as a result of a local action. 
	
	
	Modes: GSM/WCDMA */
		ELocalDeflectCall,
	/** The call has been transferred to another remote party as a result of a local 
	action. 
	
	Modes: Common */
		ELocalTransfer,
	/** The call has been placed on hold by the remote connected party. 
	
	Modes: GSM/WCDMA */
		ERemoteHold,
	/** The call has been resumed by the remote connected party. 
	
	Modes: GSM/WCDMA */
		ERemoteResume,
	/** The call has been terminated by the remote party. 
	
	Modes: Common */
		ERemoteTerminated,
	/** The call has been joined by the remote connected party to other call(s) to create/add 
	to a conference call. 
	
	Modes: GSM/WCDMA */
		ERemoteConferenceCreate,
		ERemoteTransferring,
		ERemoteTransferAlerting,
	/** The outgoing call has been barred by the remote party. 
	
	Modes: GSM/WCDMA */
		ERemoteBarred,
	/** The call is being forwarded by the remote party. 
	
	Modes: GSM/WCDMA */
		ERemoteForwarding,
	/** The call is waiting at the remote end. 
	
	Modes: GSM/WCDMA */
		ERemoteWaiting,
	/** The outgoing call has been barred by the local party. 
	
	Modes: GSM/WCDMA */
		ELocalBarred
		};

	IMPORT_C void NotifyCallEvent(TRequestStatus& aReqStatus, TMobileCallEvent& aEvent) const;

/** Describes the possible call states. */
	enum TMobileCallStatus
		{
	/** Indicates that the call status is unknown. */
		EStatusUnknown,			// same as RCall::EStatusUnknown
	/** Indicates that the call is idle. */
		EStatusIdle,			// same as RCall::EStatusIdle
		EStatusDialling,		// same as RCall::EStatusDialling
	/** Indicates that the MT call is ringing but not answered yet by the local user. */
		EStatusRinging,			// same as RCall::EStatusRinging
	/** Indicates that the local user has answered the MT call but the network has not 
	acknowledged the call connection yet. */
		EStatusAnswering,		// same as RCall::EStatusAnswering
	/** MO Call: the network notifies to the MS that the remote party is now ringing. */
		EStatusConnecting,		// same as RCall::EStatusConnecting
	/** Indicates that call is connected and active. */
		EStatusConnected,		// same as RCall::EStatusConnected
	/** Indicates that call is disconnecting. */
		EStatusDisconnecting,	// same as RCall::EStatusHangingUp
	/** Indicates that the call is disconnecting with inband data (to enable the network 
	to send an audio tone), signifying that the call is not to be released until 
	the user terminates the call. */
		EStatusDisconnectingWithInband,
	/** Indicates that call is undergoing temporary channel loss and it may or may not 
	be reconnected. */
		EStatusReconnectPending,
	/** Indicates that the call is connected but on hold. */
		EStatusHold,
	/** Indicates that the call is the non-active half of an alternating call. This 
	call is waiting for its active half or the remote end to switch alternating 
	call mode. */
		EStatusWaitingAlternatingCallSwitch,
		EStatusTransferring,
		EStatusTransferAlerting
		};

	IMPORT_C TInt GetMobileCallStatus(TMobileCallStatus& aStatus) const;
	IMPORT_C void NotifyMobileCallStatusChange(TRequestStatus& aReqStatus, TMobileCallStatus& aStatus) const;

	IMPORT_C void DialNoFdnCheck(TRequestStatus& aStatus,const TDesC& aTelNumber) const;
	IMPORT_C void DialNoFdnCheck(TRequestStatus& aStatus,const TDesC8& aCallParams,const TDesC& aTelNumber) const;
	
	/**
	Contains audio tone events.
	*/
	enum TMobileCallAudioToneEvent
		{
		/**
		Stop audio tone.
		*/
		EAudioStop,
		/**
		Start audio tone.
		*/
		EAudioStart		
		};
		
	/**
	List of 3GPP defined supervisory audio tones taken from technical specification 3GPP TS 22.001 v4.0.0 Annex F.

	This enumeration is based on the signal information element specified in Table 10.5.130/3GPP TS 24.008 v5.15.0
	*/
	enum TMobileCallAudioTones	
		{
		/** 
		No tone.  Not defined in specification used for initialisation of 
		iTone class member variable during TAudioToneV3 construction.
		*/
		ENoTone,
		/**
		Dial tone.
		*/
		EDialTone,
		/**
		Subscriber busy tone.
		*/
		ESubscriberBusyTone,
		/**
		Congestion tone.
		*/
		ECongestionTone,
		/**
		Radio path acknowledgement tone.
		*/
		ERadioPathAcknowledgement,
		/**
		Radio path not available tone.
		*/
		ERadioPathNotAvailable,
		/**
		Call dropped (Mobile Originated only).
		*/
 		EMOCallDropped,
 		/**
		Error special information.
		*/
 		EErrorSpecialInformation,
 		/**
		Number unobtainable.
		*/
 		ENumberUnobtainable,
 		/**
		Authentication failure.
		*/
 		EAuthenticationFailure,
 		/**
		Call waiting.
		*/
 		ECallWaiting,
 		/**
		Ringback tone.
		*/
		ERingback
		};

	class TAudioToneV3 :  public RMobilePhone::TMultimodeType
	/**
	Audio tone version 1 class. Contains information relating to the  call control playing of audio tones. 
	Tones maybe generated by the network (in-band) or signalled to be played locally by the ME.
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TAudioToneV3();
		
	public:
		/**
		Indicates whether the tone is starting or stopping playing.
		*/
		TMobileCallAudioToneEvent iEvent;
		/**
		Indicates which tone is to be played.
		*/
		TMobileCallAudioTones	iTone;
		/**
		Indicates whether the tone is played by the network or is to be played locally by the ME.
		*/
		TBool iPlayedLocally; 
		};

	/**
	Packaging typedef for TAudioToneV3 class.
	*/
	typedef TPckg<TAudioToneV3> TAudioToneV3Pckg;
	
	IMPORT_C void NotifyAudioToneEvent(TRequestStatus& aReqStatus, TDes8& aToneInfo) const;

	/***********************************************************************************/
	//
	// MobilePrivacy functional unit
	//
	/***********************************************************************************/

	IMPORT_C TInt SetPrivacy(RMobilePhone::TMobilePhonePrivacy aPrivacySetting) const;
	IMPORT_C void NotifyPrivacyConfirmation(TRequestStatus& aReqStatus, RMobilePhone::TMobilePhonePrivacy& aPrivacySetting) const;

	/***********************************************************************************/
	//
	// MobileTrafficChannel function unit
	//
	/***********************************************************************************/

/** Call traffic channels.

Modes: CDMA */
	enum TMobileCallTch
		{
	/** The traffic channel of the call is unknown. */
		ETchUnknown,
	/** The call has a digital traffic channel */
		ETchDigital,
	/** The call has an analog traffic channel */
		ETchAnalog
		};

	IMPORT_C TInt SetTrafficChannel(TMobileCallTch aTchRequest) const;
	IMPORT_C void NotifyTrafficChannelConfirmation(TRequestStatus& aReqStatus, TMobileCallTch& aTchType) const;

	/***********************************************************************************/
	//
	// MobileCallInformation functional unit
	//
	/***********************************************************************************/

	/**
	Remote party Identity status.

	Modes: Common

	@see TMobileCallRemotePartyInfoV1
	*/
	enum TMobileCallRemoteIdentityStatus
		{
		/**
		The remote party's identity can not be determined.  Calling
		party's Binary Coded Decimal (BCD) number is not available.
		Cause of No CLI is "unavailable".
		*/
		ERemoteIdentityUnknown,

		/**
		The remote party's identity, or BCD number, is available.
		However, cause of No CLI has not been set.
		*/
		ERemoteIdentityAvailable,

		/**
		The remote party has suppressed the transmission of its
		identity; i.e. their BCD number is not available.  Cause of No
		CLI is "reject by user".
		*/
		ERemoteIdentitySuppressed,
		/**
		The remote party's identity, or BCD number, is available.  The
		cause of No CLI is "reject by user".

		To be used where the network has specified that displaying of
		CLI information of the remote party has been rejected by the
		caller but the TMobileCallRemotePartyInfoV1::iRemoteNumber
		parameter has been populated with some other string which may
		be of use to the client.
		*/
		ERemoteIdentityAvailableNoCliRejectedByUser,

		/**
		The remote party's identity is available; a BCD number is
		available.  The cause of No CLI is "Interaction with other
		service".

		To be used where the network has specified that CLI information
		of the remote party is not available due to ineraction with
		another service.  However, the
		TMobileCallRemotePartyInfoV1::iRemoteNumber parameter has been
		populated with some other string which may be of use to the
		client.
		*/
		ERemoteIdentityAvailableNoCliInteractionWithOtherService,
		/**
		The remote party's identity, or BCD number, is unavailable.
		Cause of No CLI is "interaction with other service".
		*/
		ERemoteIdentityUnavailableNoCliInteractionWithOtherService,

		/**
		The remote party's identity, or BCD number, is available.
		Cause of No CLI is "Coin Line/ Payphone".

		To be used where the network has specified that CLI information
		of the remote party is not available as the caller is calling
		from a coin/ payphone.  However, the
		TMobileCallRemotePartyInfoV1::iRemoteNumber parameter has been
		populated with some other string which may be of use to the
		client.
		*/
		ERemoteIdentityAvailableNoCliCoinOrPayphone,
		/**
		The remote party's identity, or BCD number, is not available.
		Cause of No CLI is "Coin Line/ Payphone".
		*/
		ERemoteIdentityUnavailableNoCliCoinOrPayphone,

		/**
		The remote party's identity, or BCD number, is available.
		Cause of No CLI is "unavailable".

		To be used where the network has specified that the CLI
		information of the remote party is not available but the
		TMobileCallRemotePartyInfoV1::iRemoteNumber parameter has been
		populated with some other string which may be of use to the
		client.
		*/
		ERemoteIdentityAvailableNoCliUnavailable
		};


	/**
	The direction of the mobile call.

	Modes: Common

	@see TMobileCallRemotePartyInfoV1
	*/
	enum TMobileCallDirection
		{
	/** The direction of the call is unknown. */
		EDirectionUnknown,
	/** The call was originated by this phone, i.e. it is an outgoing call. */
		EMobileOriginated,
	/** The call was terminated by this phone, i.e. it is an incoming call. */
		EMobileTerminated
		};

	enum { KCallingNameSize=80 };

	

	class TMobileCallRemotePartyInfoV1 : public RMobilePhone::TMultimodeType
/** Defines information about the remote party of a mobile call. 
*/
		{
	public:
		IMPORT_C TMobileCallRemotePartyInfoV1();
	public:
	/** Indicates whether the remote party information in the rest of this structure 
	is valid or not.
	
	Modes: Common
	
	@see TMobileCallRemoteIdentityStatus */
		TMobileCallRemoteIdentityStatus iRemoteIdStatus;
	/** The direction of the call and hence the role of the remote party, i.e. if the 
	call is mobile originated then the remote party is the called party whereas 
	if the call is mobile terminated then the remote party is the calling party.
	
	Modes: Common
	
	@see TMobileCallDirection */
		TMobileCallDirection iDirection;
	/** The phone number of the remote party if available.
	
	Modes: Common
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iRemoteNumber;
	/** Calling party name available through the CNAP supplementary service (if provisioned). 
	
	
	Modes: Common */
		TBuf<KCallingNameSize> iCallingName;
		};

/** A typedef'd packaged TMobileCallRemotePartyInfoV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobileCallRemotePartyInfoV1> TMobileCallRemotePartyInfoV1Pckg;

	IMPORT_C void NotifyRemotePartyInfoChange(TRequestStatus& aReqStatus, TDes8& aRemotePartyInfo) const;

/** Determines which fields in the class are valid.

@see TMobileCallInfoV1 */
	enum TMobileCallInfoFlags
		{
	/** The iStartTime field is valid in the call info class.
	
	Modes: COMMON */
		KCallStartTime		= 0x00000001,
	/** The iDuration field is valid in the call info class.
	
	Modes: COMMON */
		KCallDuration		= 0x00000002,
	/** The iCallId field is valid in the call info class.
	
	Modes: COMMON */
		KCallId				= 0x00000004,
	/** The iRemoteParty field is valid in the call info class.
	
	Modes: COMMON */
		KCallRemoteParty	= 0x00000008,
	/** The iDialledParty field is valid in the call info class.
	
	Modes: COMMON */
		KCallDialledParty	= 0x00000010,
	/** The iExitCode field is valid in the call info class.
	
	Modes: COMMON */
		KCallExitCode		= 0x00000020,
	/** The iEmergency field is valid in the call info class.
	
	Modes: COMMON */
		KCallEmergency		= 0x00000040,
	/** The iForwarded field is valid in the call info class.
	
	Modes: COMMON */
		KCallForwarded		= 0x00000080,
	/** The iPrivacy field is valid in the call info class.
	
	Modes: CDMA */
		KCallPrivacy		= 0x00000100,
	/** The iTch field is valid in the call info class.
	
	Modes: CDMA */
		KCallTch			= 0x00000200,
	/** The iAlternatingCall field is valid in the call info class.
	
	Modes: GSM/WCDMA */
		KCallAlternating	= 0x00000400,
		KCallSecurity		= 0x00000800
		};

	

	class TMobileCallInfoV1 : public RMobilePhone::TMultimodeType
/** Defines general information about a mobile call. 
*/
		{
	public:
		IMPORT_C TMobileCallInfoV1();
	public:
	/** A bit-wise sum of TMobileCallInfoFlags indicating which of the following optional 
	fields contain valid data. */
		TUint32 iValid;
	/** The call service (voice, data, fax, aux. voice) that this call provides.
	
	@see RMobilePhone::TMobileService */
		RMobilePhone::TMobileService iService;
	/** The mobile call status.
	
	@see TMobileCallStatus */
		static TMobileCallStatus iStatus;
	/** The call ID number assigned to an ongoing call. Will equal -1 if the call does 
	not have an allocated ID. */
		TInt iCallId;
	/** The reason for termination of a finished call. Will equal KErrNone if the call 
	ended normally and KErrNotFound if the call has not ended. */
		TInt iExitCode;
	/** ETrue if the call is an emergency call or EFalse if it is not. */
		TBool iEmergency;
	/** For a MT call, this attribute equals ETrue if the call has been forwarded to 
	this phone or EFalse if it has not. For a MO call, this attribute equals ETrue 
	if the call has been forwarded to another destination or EFalse if it has 
	not. If the phone can not determine whether the call has been forwarded or 
	not then the attribute will return EFalse. */
		TBool iForwarded;
	/** This attribute indicates whether privacy is on or off for this call.
	
	@see RMobilePhone::TMobilePhonePrivacy */
		RMobilePhone::TMobilePhonePrivacy iPrivacy;
	/** This attribute indicates whether this call is an alternating call or not.
	
	@see RMobilePhone::TMobilePhoneAlternatingCallMode */
		RMobilePhone::TMobilePhoneAlternatingCallMode iAlternatingCall;
	/** The current duration of the call.
	
	@see TTimeIntervalSeconds */
		TTimeIntervalSeconds iDuration;
	/** This attribute indicates whether a digital or analog traffic channel is being 
	used for this call.
	
	@see TMobileCallTch */
		TMobileCallTch iTch;
	/** Information about remote party of a connected call.
	
	@see TMobileCallRemotePartyInfoV1 */
		TMobileCallRemotePartyInfoV1 iRemoteParty;
	/** The original number (including DTMF) dialled for an outgoing call.
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iDialledParty;
	/** The time and date the call started.
	
	@see TDateTime */
		TDateTime iStartTime;
	/** The name of the call.
	
	@see TName */
		TName iCallName;
	/** The name of the line on which the call is open.
	
	@see TName */
		TName iLineName;
		};

/** A typedef'd packaged TMobileCallInfoV1 for passing through a generic API function 
member. */
	typedef TPckg<TMobileCallInfoV1> TMobileCallInfoV1Pckg;
	
	class TMobileCallInfoV3 : public TMobileCallInfoV1
	/**
	Extends the TMobileCallInfoV1 claass to include extra call info parameter relating to network security.
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileCallInfoV3();
	public:
		/**
		Indicates whether Ciphering Status of a call is enabled or disabled. 
		*/
		RMobilePhone::TMobilePhoneNetworkSecurity  iSecurity;
		};
		
	typedef TPckg<TMobileCallInfoV3> TMobileCallInfoV3Pckg;

	IMPORT_C TInt GetMobileCallInfo(TDes8& aCallInfo) const;

	/***********************************************************************************/
	//
	// MobileCallEmergency functional unit
	//
	/***********************************************************************************/

	IMPORT_C void DialEmergencyCall(TRequestStatus& aReqStatus, const TDesC& aNumber) const;

	/***********************************************************************************/
	//
	// MobileCallCompletion
	//
	/***********************************************************************************/

	IMPORT_C void ActivateCCBS(TRequestStatus& aReqStatus, TInt& aIndex) const;
	IMPORT_C TInt RejectCCBS() const;
		//
	// User-To-User Signalling Functional Unit
	//
	/***********************************************************************************/

/** The UUS capabilities of the call.

Modes: GSM/WCDMA. */
	enum TMobileCallUUSCaps			// UUS capabilities of the call
		{
	/** Indicates that MS supports UUS1 implicit request. */
		KCapsSetupUUS1Implicit=0x00000001,
	/** Indicates that MS supports UUS1 explicit request. */
		KCapsSetupUUS1Explicit=0x00000002,
	/** Indicates that MS supports UUS2 request. */
		KCapsSetupUUS2=0x00000004,
	/** Indicates that MS supports UUS3 request. */
		KCapsSetupUUS3=0x00000008,
	/** Indicates that MS supports activating more than one UUS request at a time. */
		KCapsSetupMultipleUUS=0x00000010,
	/** Indicates that UUS1 is active for this call. */
		KCapsActiveUUS1=0x00000020,
	/** Indicates that UUS2 is active for this call. */
		KCapsActiveUUS2=0x00000040,
	/** Indicates that UUS3 is active for this call. */
		KCapsActiveUUS3=0x00000080
		};

	IMPORT_C TInt GetUUSCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyUUSCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

/** UUS Service requests.

Modes: GSM/WCDMA */
	enum TMobileCallUUSReqs			// UUS Service requests
		{
	/** UUS1 is implicitly requested. */
		KUUS1Implicit=0x00000001,
	/** UUS1 is explicitly requested, but it is not mandatory for this call to proceed. */
		KUUS1ExplicitRequested=0x00000002,
	/** UUS1 is explicitly requested and it is mandatory for this call to proceed. */
		KUUS1ExplicitRequired=0x00000004,
	/** UUS2 is (explicitly) requested, but it is not mandatory for this call to proceed. */
		KUUS2Requested=0x00000008,
	/** UUS2 is (explicitly) requested and it is mandatory for this call to proceed. */
		KUUS2Required=0x00000010,
	/** UUS3 is (explicitly) requested, but it is not mandatory for this call to proceed. */
		KUUS3Requested=0x00000020,
	/** UUS3 is (explicitly) requested and it is mandatory for this call to proceed. */
		KUUS3Required=0x00000040
		};

	enum 
		{
		KMaxUUISize = 129,
		};

/** Buffer for the UUI element. */
	typedef TBuf<KMaxUUISize> TMobileCallUUI;

	class  TMobileCallUUSRequestV1 : public RMobilePhone::TMultimodeType
/** The mobile Call User-to-User Signaling request. 
*/
		{
	public:
		IMPORT_C  TMobileCallUUSRequestV1();
	public:
	/** This field indicates whether the specified service is requested or required 
	for the call. */
		TUint             iServiceReq;
	/** The UUI element. This field only contains data if iServiceReq indicates UUS1.
	
	@see TMobileCallUUI */
		TMobileCallUUI	  iUUI;
		};
	
/** A typedef'd packaged TMobileCallUUSRequestV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileCallUUSRequestV1> TMobileCallUUSRequestV1Pckg;

	IMPORT_C void ActivateUUS(TRequestStatus& aReqStatus, const TDesC8& aUUSRequest) const;
	IMPORT_C void SendUUI(TRequestStatus& aReqStatus, TBool aMore, const TMobileCallUUI& aUUI) const;
	IMPORT_C void ReceiveUUI(TRequestStatus& aReqStatus, TMobileCallUUI& aUUI) const;
	IMPORT_C void HangupWithUUI(TRequestStatus& aReqStatus, const TMobileCallUUI& aUUI) const;
	IMPORT_C void AnswerIncomingCallWithUUI(TRequestStatus& aReqStatus, const TDesC8& aCallParams, const TMobileCallUUI& aUUI) const;
	
	/***********************************************************************************/
	//
	// Etel 3rd Party v1.0 Parameter classes
	//
	/***********************************************************************************/
	
	class TEtel3rdPartyMobileCallParamsV1 : public RCall::TCallParams
/** Defines the parameters used to set-up of a call originated from an ETel 3rd Party client. 
@publishedPartner
@released
*/
		{
	public:
		IMPORT_C TEtel3rdPartyMobileCallParamsV1();
	public:
	/** Call Id restriction setting to be used for this call.
	
	@see TMobileCallIdRestriction */
		TMobileCallIdRestriction iIdRestrict;
	/** Specifies whether this call attempt is user initiated (EFalse) or a client initiated 
	redial (ETrue). */
		TBool iAutoRedial;		
		};
		
/** A typedef'd packaged TEtel3rdPartyMobileCallParamsV1 for passing through a generic API 
function member. */
	typedef TPckg<TEtel3rdPartyMobileCallParamsV1>TEtel3rdPartyMobileCallParamsV1Pckg;	

	
private:
	RMobileCall(const RMobileCall& aCall);
	CMobileCallPtrHolder* iMmPtrHolder;
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};


/*********************************************************/
//
// Line based functionality (RMobileLine)
// 
/*********************************************************/



class CMobileLinePtrHolder;

class RMobileLine : public RLine
/** Provides access to the functionality associated with a specific mobile line. 
*/
	{
public:
	IMPORT_C RMobileLine();

	/***********************************************************************************/
	//
	// MobileLineStatus functional unit
	// 
	/***********************************************************************************/

	IMPORT_C TInt GetMobileLineStatus(RMobileCall::TMobileCallStatus& aStatus) const;
	IMPORT_C void NotifyMobileLineStatusChange(TRequestStatus& aReqStatus, RMobileCall::TMobileCallStatus& aStatus) const;

	//
	// Additional Caps
	//
/** Enumerated auxiliary capabilities. */
	enum TMobileLineAdditionalCaps
		{
	/** Indicates whether the line is a Primary or Auxiliary voice line offset added 
	so that core Etel and additional line caps can be returned in one TUint. */
		KCapsAuxVoice=0x00000008	
		};

private:
	RMobileLine(const RMobileLine& aLine);
	CMobileLinePtrHolder* iMmPtrHolder;
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};


/*********************************************************/
//
// SMS Messaging (RMobileSmsMessaging)
// 
/*********************************************************/



class CMobilePhoneSmspList;
class CSmsMessagingPtrHolder;

class RMobileSmsMessaging : public RTelSubSessionBase
/** Provides client access to SMS messaging functionality provided by TSY.
@publishedPartner
@released 
*/
	{
public:

	friend class CRetrieveMobilePhoneSmspList;

	IMPORT_C RMobileSmsMessaging();

	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

/** Defines capabilities of SMS messaging.

Modes: GSM/WCDMA */
	enum TMobileSmsModeCaps
		{
	/** SMS is supported in GSM and WCDMA modes. SMS are sent across MM ETel API in 
	a GSM 03.40 TPDU format.
	
	Modes: GSM/WCDMA */
		KCapsGsmSms=0x00000001,
	/** SMS is supported in CDMA mode. SMS are sent across MM ETel API in a IS-637 
	Teleservice message PDU format. 
	
	Modes: CDMA */
		KCapsCdmaSms=0x00000002
		};

/** Defines SMS control capabilities.

Modes: Common */
	enum TMobileSmsControlCaps
		{
	/** TSY supports receiving incoming SMS that have been stored and acknowledged 
	by the phone prior to forwarding to the TSY. If this flag is set then KCapsReceiveEither 
	will not be set and the client can receive stored messages only while the 
	TSY-phone link is in "receive stored" mode.
	
	Modes: Common */
		KCapsReceiveStored=0x00000001,
	/** TSY supports receiving incoming SMS that have been acknowledged by the phone 
	but have NOT already been stored. It is the client's responsibility to do 
	the storage. If this flag is set then KCapsReceiveEither will not be set and 
	the client can receive unstored messages only while the TSY-phone link is 
	in "receive unstored with phone ack" mode.
	
	Modes: Common */
		KCapsReceiveUnstoredPhoneAck=0x00000002,
	/** TSY supports receiving incoming SMS that have NOT already been stored and acknowledged
	by the phone. It is the client's responsibility to do both the storage and 
	the acknowledgment or rejection. If this flag is set then KCapsReceiveEither 
	will not be set and the client can receive unstored messages only while the 
	TSY-phone link is in "receive unstored with client ack" mode.
	
	Modes: Common */
		KCapsReceiveUnstoredClientAck=0x00000004,
	/** TSY supports receiving either stored or unstored incoming SMS at any time. 
	If this flag is set then any other KCapsReceive... flags will not be set and 
	the client can receive stored or unstored messages while the TSY-phone link 
	is in "receive either" mode.
	
	Modes: Common */
		KCapsReceiveEither=0x00000008,
	/** TSY supports creating a default acknowledgment or rejection TPDU using only 
	a "cause code" supplied by the client. If this flag is not set then the client 
	must supply the full ack or nack TPDU if it calls RMobileSmsMessaging::AckSmsStored() 
	or RMobileSmsMessaging::NackSmsStored().
	
	Modes: Common */
		KCapsCreateAck=0x00000010,
	/** TSY supports sending SMS messages but does not support returning the service 
	centre's acknowledgment of the submitted message to the client.
	
	Modes: Common */
		KCapsSendNoAck=0x00000020,
	/** TSY supports sending SMS messages and also supports returning the service centre's 
	acknowledgment of the submitted message to the client.
	
	Modes: GSM/WCDMA */
		KCapsSendWithAck=0x00000040,
	/** TSY supports retrieval of the SMS parameter list.
	
	Modes: GSM/WCDMA */
		KCapsGetSmspList=0x00000080,
	/** TSY supports storage of the SMS parameter list
	
	Modes: GSM/WCDMA */
		KCapsSetSmspList=0x00000100
		};

	class TMobileSmsCapsV1 : public RMobilePhone::TMultimodeType
/** Defines capabilities of SMS messaging.
*/
		{
	public:
		IMPORT_C TMobileSmsCapsV1();

	/** Sum of TMobileSmsModeCaps constants.
	
	Modes: Common */
		TUint32 iSmsMode;
	/** Sum of TMobileSmsControlCaps constants.
	
	Modes: Common */
		TUint32 iSmsControl;
		};

/** A typedef'd packaged TMobileSmsCapsV1 for passing through a generic API member 
function. */
	typedef TPckg<TMobileSmsCapsV1> TMobileSmsCapsV1Pckg;

	IMPORT_C TInt GetCaps(TDes8& aCaps) const;

	// Definitions for sizes of TPDU and User Data fields
	enum 
		{ 
		KGsmTpduSize = 165,		// 140 bytes user data + 25 bytes TPDU header
		KCdmaTpduSize  = 256	// Max size of Bearer Data in Transport Layer message
		};

/** A typedef'd buffer for GSM or WCDMA message data. */
	typedef TBuf8<KGsmTpduSize>			TMobileSmsGsmTpdu;
/** A typedef'd buffer for CDMA message data. */
	typedef TBuf8<KCdmaTpduSize>		TMobileSmsCdmaTpdu;

	/***********************************************************************************/
	//
	// Enum used by TSY to distinguish which SMS attribute class is used by client
	//
	/***********************************************************************************/

/** Used by TSY to distinguish which SMS attribute class is used by client.

Modes: Common

@see RMobileSmsMessaging::TMobileSmsSendAttributesV1 */
	enum TMobileSmsAttributeExtensionId
		{
	/** The iExtensionId contents indicate that the packaged class is a TMobileSmsAttributesV1. */
		KETelMobileSmsAttributesV1=KETelExtMultimodeV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileSmsReceiveAttributesV1. */
		KETelMobileSmsReceiveAttributesV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileSmsSendAttributesV1. */
		KETelMobileSmsSendAttributesV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileSmsCdmaSendAttributesV4. */
		KETelMobileSmsCdmaSendAttributesV4=KETelExtMultimodeV4
		};

/** Defines common attributes of all SMS messages.

Modes: CDMA

@see TMobileSmsAttributesV1 */
	enum TMobileSmsAttributeFlags
		{
	/** The iCdmaTeleservice field is valid in the attribute class.
	
	Modes: CDMA */
		KCdmaTeleservice = 0x00000001,
	/** The iCdmaServiceCategory field is valid in the attribute class.
	
	Modes: CDMA */
		KCdmaServiceCategory = 0x00000002,
	/** The iGsmServiceCentre field is valid in the attribute class.
	
	Modes: GSM/WCDMA */
		KGsmServiceCentre = 0x00000004,
	/** The iDataFormat field is valid in the attribute class.
	
	Modes: Common */
		KSmsDataFormat = 0x00000008,	
	/** The iOriginator or iDestination field is valid in the attribute class.
	
	Modes: Common */
		KRemotePartyInfo = 0x00000010,
	/** The iStatus field is valid in the attribute class.
	
	Modes: Common */
		KIncomingStatus = 0x00000020,
	/** The iStore and iStoreIndex fields are valid in the attribute class.
	
	Modes: Common */
		KStorageLocation = 0x00000040,
	/** The iMsgRef field is valid in the attribute class.

	Modes: Common */
		KMessageReference = 0x00000080,
	/** The iSubmitReport field is valid in the attribute class.
	
	Modes: GSM/WCDMA */
		KGsmSubmitReport = 0x00000100,
	/** The iMore field is valid in the attribute class.
	
	Modes: Common */
		KMoreToSend = 0x00000200,
	/** Indicates to the TSY that it should keep the traffic channel open since there is
	    another message ready to be sent immediately after this one (typically used when
	    sending messages to multiple recipients). TSY should then keep the channel open 
	    until a message is sent with this bit cleared.
	
	Modes: CDMA */
		KCdmaKeepChannelOpen = 0x00000400,
	/** Indicates to the TSY that it must wait for the Transport Layer Acknowledgement from the network
	
	Modes: CDMA */
		KCdmaTLAckRequired = 0x00000800,
	/** The iAddressAuthentication field is valid in the attribute class.
	
	Modes: CDMA */
		KCdmaAddressAuthentication = 0x00001000
		};

/** Defines the SMS data format.

Modes: Common */
	enum TMobileSmsDataFormat
		{
	/** The format is not specified.

	Modes: Common */
		EFormatUnspecified,
	/** The message data format complies to a SMS TPDU coded as octets according to 
	GSM 03.40.
	
	Modes: GSM/WCDMA */
		EFormatGsmTpdu,
	/** The message data format complies to a SMS Teleservice PDU coded as octets according 
	to IS-637.
	
	Modes: CDMA */
		EFormatCdmaTpdu
		};

	class TMobileSmsAttributesV1 : public RMobilePhone::TMultimodeType
	/** Defines common attributes of all SMS messages. 
	@publishedPartner
	@released
	*/
		{
	protected:
		TMobileSmsAttributesV1();
	public:
	/** The bit-mask flags from TMobileSmsAttributeFlags indicating which attributes 
	are present in this instance.
	
	Modes: Common */
		TUint32 iFlags;
	/** The format of the message data buffer .
	
	Modes: Common
	
	@see TMobileSmsDataFormat */
		TMobileSmsDataFormat iDataFormat;
	/** The teleservice this message belongs to, coded according to SMS teleservice 
	identifier values table in TIA/EIA-41-D.
	
	Modes: CDMA */
		TInt iCdmaTeleservice;
	/** The service category this message belongs to.
	
	Modes: CDMA */
		TInt iCdmaServiceCategory;
	/** The GSM service centre used for this SMS.
	
	Modes: GSM/WCDMA
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iGsmServiceCentre;
		};

/** A typedef'd packaged TMobileSmsAttributesV1 for passing through a generic 
API member function. */
	typedef TPckg<TMobileSmsAttributesV1> TMobileSmsAttributesV1Pckg;

/** Defines attributes of incoming SMS messages.

Modes: Common */
	enum TMobileSmsIncomingStatus
		{
	/** The status of the incoming SMS is unknown. */
		EMtMessageUnknownStatus,
	/** The incoming SMS is not stored phone-side but has already been acknowledged 
	by the phone. */
		EMtMessageUnstoredPhoneAck,
	/** The incoming SMS is not stored phone-side and needs to be acknowledged by the 
	client. */
		EMtMessageUnstoredClientAck,
	/** The incoming SMS is stored phone-side. */
		EMtMessageStored
		};

	class TMobileSmsReceiveAttributesV1 : public TMobileSmsAttributesV1
	/** Defines attributes of incoming SMS messages. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileSmsReceiveAttributesV1();
	public:
	/** Indicates the status of the incoming message -whether it is stored phone-side 
	or has been acknowledged by the phone.
	
	Modes: Common
	
	@see TMobileSmsIncomingStatus */
		TMobileSmsIncomingStatus	 iStatus;	// indicates if MT message is stored phone-side
	/** If the message is stored phone-side, indicates the index (within the phone-side 
	store) where the message is stored.
	
	Modes: Common */
		TInt						 iStoreIndex;// used if MT message is stored phone-side
	/** If the message is stored phone-side, indicates the name of the appropriate 
	phone-side store.
	
	Modes: Common
	
	@see RMobilePhone::TMobileName */
		RMobilePhone::TMobileName	 iStore;		// used if MT message is stored phone-side
	/** The address of the originator of the SMS.

	Modes: Common
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iOriginator;
		};

/** A typedef'd packaged TMobileSmsReceiveAttributesV1 for passing through a generic 
API member function. */
	typedef TPckg<TMobileSmsReceiveAttributesV1> TMobileSmsReceiveAttributesV1Pckg;

	

	class TMobileSmsSendAttributesV1 : public TMobileSmsAttributesV1
	/** Defines attributes of sent SMS messages.
	@publishedPartner
	@released */
		{
	public:
		IMPORT_C TMobileSmsSendAttributesV1();
	public:
	/** The message reference assigned to a sent message.
	
	Modes: Common */
		TUint16						 iMsgRef;
	/** A boolean indicating whether the client is going to send another SMS immediately 
	after this one. Equals ETrue if this is the case, EFalse if it is not.
	
	Modes: Common */
		TBool						 iMore;
	/** The SMS-SUBMIT-REPORT TPDU received from network in response to a sent message.
	
	Modes: GSM/WCDMA
	
	@see TMobileSmsGsmTpdu */
		TMobileSmsGsmTpdu			 iSubmitReport;
	/** The address of the destination of the SMS.
	
	Modes: Common
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iDestination;
		};
	
/** A typedef'd packaged TMobileSmsSendAttributesV1 for passing through a generic 
API member function. */
	typedef TPckg<TMobileSmsSendAttributesV1> TMobileSmsSendAttributesV1Pckg;

	class TMobileSmsCdmaSendAttributesV4 : public TMobileSmsAttributesV1
	/**
	Defines attributes of sent SMS messages (CDMA only).

	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileSmsCdmaSendAttributesV4();
	public:
		/** 
		The message id allocated by the SMS stack. The TSY should
		retrieve the value from iCdmaTeleserviceId to determine
		which teleservice this message id corresponds to. 
		*/
		TUint16 iMsgRef;
		/** Indicates whether the client is going to send another 
		PDU immediately after this one (typically used when sending
		messages of more than one PDU). Equals ETrue if at least 
		one more PDU is needed to complete the message and EFalse
		otherwise.
		*/
		TBool iMore;
		/** TPDU received from network in response to a sent message */
		TMobileSmsCdmaTpdu iTLAck;
		/** The address of the destination of the SMS. */
		RMobilePhone::TMobileAddress iDestination;
		/** Transport layer authentication parameter */
		TUint32 iAddressAuthentication;
		};

/** A typedef'd packaged TMobileSmsCdmaSendAttributesV4 for passing through a generic 
API member function. */
	typedef TPckg<TMobileSmsCdmaSendAttributesV4> TMobileSmsCdmaSendAttributesV4Pckg;

	//
	// Setting up the storage & acknowledgement mode
	//

/** Defines the SMS receive modes.

Modes: Common */
	enum TMobileSmsReceiveMode
		{
	/** Receive mode is unspecified and phone will use its default. */
		EReceiveModeUnspecified,
	/** Phone will store and acknowledge all incoming messages before passing them 
	onto TSY. */
		EReceiveUnstoredPhoneAck,	// client stores but phone acknowledges message
	/** Phone will acknowledge but NOT store all incoming messages before passing them 
	onto TSY. It is client's responsibility to store the message. */
		EReceiveUnstoredClientAck,	// client acknowledges and stores message
	/** Phone will NOT acknowledge or store any incoming messages before passing them 
	onto TSY. It is client's responsibility to attempt storage and then either
	acknowledge or reject the message. */
		EReceiveStored,				// phone acknowledges and store message
	/** Phone may pass on either stored or unstored messages to TSY. It is client's 
	responsibility to check RMobileSmsMessaging::TMobileSmsReceiveAttributesV1::iStatus 
	to determine what action(s) the client needs to take for a message. */
		EReceiveEither				// client deals with stored & unstored messages
		};

	IMPORT_C void SetReceiveMode(TRequestStatus& aReqStatus, TMobileSmsReceiveMode aReceiveMode) const;
	IMPORT_C TInt GetReceiveMode(TMobileSmsReceiveMode& aReceiveMode) const;
	IMPORT_C void NotifyReceiveModeChange(TRequestStatus& aStatus, TMobileSmsReceiveMode& aReceiveMode);

	/***********************************************************************************/
	//
	// Incoming SMS
	//
	/***********************************************************************************/

	IMPORT_C void ReceiveMessage(TRequestStatus& aReqStatus, TDes8& aMsgData, TDes8& aMsgAttributes) const;

	/***********************************************************************************/
	//
	// Responding to incoming SMS
	//
	/***********************************************************************************/

	IMPORT_C void AckSmsStored(TRequestStatus& aReqStatus, const TDesC8& aMsgData, TBool aFull=EFalse) const;
	IMPORT_C void NackSmsStored(TRequestStatus& aReqStatus, const TDesC8& aMsgData, TInt aRpCause) const;
	IMPORT_C void ResumeSmsReception(TRequestStatus& aReqStatus) const;

	/***********************************************************************************/
	//
	// Outgoing SMS
	//
	/***********************************************************************************/

	IMPORT_C void SendMessage(TRequestStatus& aReqStatus, const TDesC8& aMsgData, TDes8& aMsgAttributes) const;
	IMPORT_C void SendMessageNoFdnCheck(TRequestStatus& aReqStatus, const TDesC8& aMsgData, TDes8& aMsgAttributes) const;

/** Defines the SMS bearer.

Modes: GSM */
	enum TMobileSmsBearer
		{
	/** SMS messages will only be sent over a packet-switched (GPRS) network. */
		ESmsBearerPacketOnly,
	/** SMS messages will only be sent over a circuit-switched (GSM) network. */
		ESmsBearerCircuitOnly,
	/** SMS messages will be sent over the packet-switched (GPRS) network if possible, 
	otherwise over circuit-switched (GSM) network. */
		ESmsBearerPacketPreferred,
	/** SMS messages will be sent over the circuit-switched (GSM) network if possible, 
	otherwise over packet-switched (GPRS) network. */
		ESmsBearerCircuitPreferred
		};

	IMPORT_C void SetMoSmsBearer(TRequestStatus& aReqStatus, TMobileSmsBearer aBearer) const;
	IMPORT_C TInt GetMoSmsBearer(TMobileSmsBearer& aBearer) const;
	IMPORT_C void NotifyMoSmsBearerChange(TRequestStatus& aReqStatus, TMobileSmsBearer& aBearer);

	/***********************************************************************************/
	//
	// Get information on phone-side SMS storage
	//
	/***********************************************************************************/

	IMPORT_C TInt EnumerateMessageStores(TInt& aCount) const;
	IMPORT_C void GetMessageStoreInfo(TRequestStatus& aReqStatus, TInt aIndex, TDes8& aInfo) const;

	/***********************************************************************************/
	//
	// Read/Write SMS parameters to phone-side storage
	//
	/***********************************************************************************/

	enum { KMaxSmspTextSize=30 };

/** Defines the valid SMS parameters store.

Modes: GSM/WCDMA

@see TMobileSmspEntryV1 */
	enum TMobileSmspStoreValidParams
		{
	/** The entry includes a valid iDestination field. */
		KDestinationIncluded=0x00000001,
	/** The entry includes a valid iServiceCentre field. */
		KSCAIncluded=0x00000002,
	/** The entry includes a valid iProtocolId field. */
		KProtocolIdIncluded=0x00000004,
	/** The entry includes a valid iDcs field. */
		KDcsIncluded=0x00000008,
	/** The entry includes a valid iValidityPeriod field. */
		KValidityPeriodIncluded=0x00000010
 		};

	class TMobileSmspEntryV1 : public RMobilePhone::TMultimodeType

	/** Defines a set of SMS parameters. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileSmspEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** The slot index where this SMSP entry is stored in the SIM's SMSP file. */
		TInt iIndex;
	/** A bit-wise sum of the constants defined in TMobileSmspStoreValidParams, that 
	specifies which parameters are valid within this entry. */
		TUint32	iValidParams;
	/** Default protocol ID. Coded according to GSM 03.40. */
		TUint8 iProtocolId;
	/** Default data coding scheme. Coded according to GSM 03.40. */
		TUint8 iDcs;
	/** Default validity period, in relative format and coded on 8 bits as defined 
	by GSM 03.40. */
		TUint8 iValidityPeriod;
	/** Reserved for future use. */
		TUint8 iReservedFiller;
	/** Default destination for outgoing SMS.
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iDestination;
	/** Default service centre for outgoing SMS.
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iServiceCentre;
	/** The alpha-tag associated with this SMSP entry, expressed as Unicode characters. */
		TBuf<KMaxSmspTextSize> iText;
		};

/** A typedef'd packaged TMobileSmspEntryV1 for passing through a generic API member
function. */
	typedef TPckg<TMobileSmspEntryV1> TMobileSmspEntryV1Pckg;
	IMPORT_C void StoreSmspListL(TRequestStatus& aReqStatus, CMobilePhoneSmspList* aSmspList) const;
	IMPORT_C void NotifySmspListChange(TRequestStatus& aReqStatus) const;

private:
	RMobileSmsMessaging(const RMobileSmsMessaging&);
	CSmsMessagingPtrHolder* iSmsMessagingPtrHolder;
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};


/*********************************************************/
//
// Broadcast Messaging (RMobileBroadcastMessaging)
// 
/*********************************************************/



class CMobilePhoneBroadcastIdList;

class CCbsMessagingPtrHolder;
class RMobileBroadcastMessaging : public RTelSubSessionBase
/** This sub-session provides access to the broadcast message services provided 
by GSM/WCDMA and CDMA networks.

Clients will open a RMobileBroadcastMessaging sub-session and then wait for 
incoming broadcast messages. The broadcast messages received can depend upon 
a "message filter" which defines the languages and/or identifiers of acceptable 
(or unacceptable) messages. This sub-session and the function members within 
this section must be supported if the TSY indicates that it supports the MobileBroadcastMessaging
functional unit. 

@publishedPartner
@released*/
	{
public:
	
	friend class CRetrieveMobilePhoneBroadcastIdList;

	IMPORT_C RMobileBroadcastMessaging();

	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

	/***********************************************************************************/
	//
	// Broadcast messaging capabilities
	//
	/***********************************************************************************/

/** Broadcast capabilities.

Modes:GSM/WCDMA */
	enum TMobileBroadcastModeCaps
		{
	/** GSM 03.41 cell broadcast messages are supported.
	
	Modes:GSM/WCDMA */
		KCapsGsmTpduFormat = 0x00000001,
	/** IS-637-A broadcast messages are supported.
	
	Modes:CDMA */
		KCapsCdmaTpduFormat = 0x00000002,
	/** 3GPP 25.324 Release 4 cell broadcast messages are supported.
	
	Modes: WCDMA */
		KCapsWcdmaTpduFormat = 0x00000004
		};

/** Broadcast message filter capabilities.

Modes: Common

@see RMobileBroadcastMessaging::GetLanguageFilter() */
	enum TBroadcastMessagingFilterCaps
		{
	/** Phone supports switching broadcast messages on or off. This means the EbroadcastAcceptNone 
	and EBroadcastAcceptAll settings of TMobilePhoneBroadcastFilter are supported.
	
	Modes: Common */
		KCapsSimpleFilter = 0x00000001,
	/** Phone supports filtering of broadcast messages depending upon their language. 
	The language filter is a list of languages used only for broadcast filtering.
	
	Modes: Common
	
	@see RMobileBroadcastMessaging::GetLanguageFilter() */
		KCapsLangFilter = 0x00000002,
	/** Phone supports filtering of broadcast messages depending upon their subject. 
	The subject of a message is identified in GSM/WCDMA mode by the Cell Broadcast 
	Message Identifier (CBMI) and in CDMA mode by the Service Category.
	
	Modes: Common */
		KCapsIdFilter = 0x00000004
		};

	

	class TMobileBroadcastCapsV1 : public RMobilePhone::TMultimodeType
	/** Defines capabilities of Broadcast messaging. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileBroadcastCapsV1();
	public:
	/** Sum of TMobileBroadcastModeCaps constants.
	
	Modes: GSM/WCDMA */
		TUint32 iModeCaps;
	/** Sum of TBroadcastMessagingFilterCaps constants.
	
	Modes: GSM/WCDMA */
		TUint32 iFilterCaps;
		};

/** A typedef'd packaged TMobileBroadcastCapsV1 for passing through a generic API 
function member. */
	typedef TPckg<TMobileBroadcastCapsV1> TMobileBroadcastCapsV1Pckg;

	IMPORT_C TInt GetCaps(TDes8& aCaps) const;

/** Defines the broadcast attributes.

Modes: Common */
	enum TMobileBroadcastAttributeFlags
		{
	/** The iFormat field is valid in the attribute class.
	
	Modes: Common */
		KBroadcastDataFormat = 0x00000001,
	/** The iServiceCategory field is valid in the attribute class.
	
	Modes: CDMA */
		KCdmaServiceCategory = 0x00000002
		};

/** The mobile broadcast data format, used byTMobileBroadcastAttributesV1.

Modes: Common */
	enum TMobileBroadcastDataFormat
		{
	/** The message data format is not specified.
	
	Modes: Common */
		EFormatUnspecified,
	/** The message data format complies to a Cell Broadcast TPDU coded as 88 octets 
	(6 for header and 82 for message data) according to GSM 03.41.
	
	Modes: GSM/WCDMA */
		EFormatGsmTpdu,
	/** The message data format complies to IS-637-A encoding of the Bearer Data parameter 
	within the Transport Layer's SMS-Broadcast message.
	
	Modes: CDMA */
		EFormatCdmaTpdu,
	/** The message data format complies to a Cell Broadcast TPDU coded as 1252 octets 
	(6 for header and a maximum of 1246 for message data) according to 3GPP 25.324.
	
	Modes: WCDMA */
		EFormatWcdmaTpdu
		};

	

	class TMobileBroadcastAttributesV1 : public RMobilePhone::TMultimodeType
	/** Defines attributes of a Broadcast message.
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileBroadcastAttributesV1();
	public:
	/** The bit-mask flags indicating which attributes are present in this instance.
	
	Modes: Common
	
	@see TMobileBroadcastAttributeFlags */
		TUint32	iFlags;
	/** Format of the message data buffer.
	
	Modes: Common
	
	@see TMobileBroadcastDataFormat */
		TMobileBroadcastDataFormat	iFormat;
	/** Service category of the message.
	
	Modes: CDMA */
		TInt iServiceCategory;
		};

/** A typedef'd packaged TMobileBroadcastAttributesV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobileBroadcastAttributesV1> TMobileBroadcastAttributesV1Pckg;


	

	class TMobileBroadcastAttributesV2 : public TMobileBroadcastAttributesV1
	/** Defines attributes of a UMTS Broadcast message for version v2.0 of the API. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileBroadcastAttributesV2();
	public:
	/** The number of pages that the current broadcast message consists of. The maximum 
	number of pages for WCDMA Broadcast messages is 15. */
		TInt	 iNumberOfPages;
	/** This parameter is used to store the message type for this broadcast message. */
		TUint8	 iMessageType;
	/** This parameter is used to store the message id for this broadcast message.
	
	This parameter is used to store the serial number for this broadcast message.
	
	This parameter is used to store the data coding scheme for this broadcast 
	message. */
		TUint16	 iMessageId;
	/** This parameter is used to store the serial number for this broadcast message. */
		TUint16	 iSerialNum;
	/** This parameter is used to store the data coding scheme for this broadcast message. */
		TUint8	 iDCS;
		};

/** A typedef'd packaged TMobileBroadcastAttributesV1 for passing through a generic 
API function member. */
	typedef TPckg<TMobileBroadcastAttributesV2> TMobileBroadcastAttributesV2Pckg;

	/***********************************************************************************/
	//
	// Receiving broadcast messages
 	//
	/***********************************************************************************/

	/** A constant which defines the length of the buffer to be passed to ReceiveMessage.	
	
	This constant should be used for all message types: GSM, CDMA and WCDMA.*/
	enum
		{
		KBroadcastPageSize = 88	
		};
	
	/** Buffer for received messages. 
	
	This buffer should be used for all message types: GSM, CDMA and WCDMA.*/
	typedef TBuf8<KBroadcastPageSize> TBroadcastPageData;

	/** Old buffer sizes.  KBroadcastPageSize should be used instead. */
	enum 
		{
		KGsmBroadcastDataSize = KBroadcastPageSize,
		KCdmaBroadcastDataSize = KBroadcastPageSize,
		KWCdmaBroadcastPageSize = KBroadcastPageSize
		};

	/** Buffer for GSM messages.  TBroadcastPageData should be used instead. */
	typedef TBuf8<KGsmBroadcastDataSize>  TGsmBroadcastMessageData;
	/** Buffer for CDMA messages.  TBroadcastPageData should be used instead.  */
	typedef TBuf8<KCdmaBroadcastDataSize> TCdmaBroadcastMessageData;
	/** Buffer for WCDMA messages.  TBroadcastPageData should be used instead. */
	typedef TBuf8<KWCdmaBroadcastPageSize> TWCdmaBroadcastPageData;

	IMPORT_C void ReceiveMessage(TRequestStatus& aReqStatus, TDes8& aMsgData, TDes8& aMsgAttributes) const;

	/***********************************************************************************/
	//
	// Filters
	//
	/***********************************************************************************/

/** The filter settings of the mobile phone.

Modes: Common */
	enum TMobilePhoneBroadcastFilter
		{
	/** The phone does not have a filter setting. */
		EBroadcastFilterUnspecified,
	/** The phone is not accepting any broadcast messages. */
		EBroadcastAcceptNone,
	/** The phone is accepting all broadcast messages. */
		EBroadcastAcceptAll,
	/** The phone is accepting those broadcast messages included within the language 
	and identifier filters. */
		EBroadcastAcceptFilter,
	/** The phone is rejecting those broadcast messages included within the language 
	or identifier filters. */
		EBroadcastRejectFilter
		};

	IMPORT_C TInt GetFilterSetting(TMobilePhoneBroadcastFilter& aSetting) const;
	IMPORT_C void SetFilterSetting(TRequestStatus& aReqStatus, TMobilePhoneBroadcastFilter aSetting) const;
	IMPORT_C void NotifyFilterSettingChange(TRequestStatus& aReqStatus, TMobilePhoneBroadcastFilter& aSetting) const;

	IMPORT_C void GetLanguageFilter(TRequestStatus& aReqStatus, TDes16& aLangFilter) const;
	IMPORT_C void SetLanguageFilter(TRequestStatus& aReqStatus, const TDesC16& aLangFilter) const;
	IMPORT_C void NotifyLanguageFilterChange(TRequestStatus& aReqStatus, TDes16& aLangFilter) const;

	class TMobileBroadcastIdEntryV1 : public RMobilePhone::TMultimodeType
	/** In GSM - defines a Cell Broadcast Message Identifier (CBMI) list entry. In 
	CDMA - defines a Service Category list entry. 
	@publishedPartner
	@released
	*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
		IMPORT_C TMobileBroadcastIdEntryV1();
	public:
	/** The value of the message identifier. */
		TUint16	iId;
		};

/** Defines the broadcast types. */
	enum TMobileBroadcastIdType
		{
	/** GSM broadcast. */
		EGsmBroadcastId,
	/** CDMA broadcast. */
		ECdmaBroadcastId
		};

	IMPORT_C void StoreBroadcastIdListL(TRequestStatus& aReqStatus, CMobilePhoneBroadcastIdList* aIdList, TMobileBroadcastIdType aIdType);
	IMPORT_C void NotifyBroadcastIdListChange(TRequestStatus& aReqStatus) const;

private:
	RMobileBroadcastMessaging(const RMobileBroadcastMessaging&);
	CCbsMessagingPtrHolder* iCbsMessagingPtrHolder;
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};

/*********************************************************/
//
// USSD Messaging (RMobileUssdMessaging)
// 
/*********************************************************/



class CUssdMessagingPtrHolder;
class RMobileUssdMessaging : public RTelSubSessionBase
/** Provides client access to USSD functionality provided by TSY. 
*/
	{
public:
	IMPORT_C RMobileUssdMessaging();

	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

/** Defines the USSD Messaging Format Capabilities.

Modes: GSM/WCDMA */
	enum TMobileUssdFormatCaps
		{
	/** USSD messages coded as a packed string within 160 octets, as defined for a 
	ussd-String within GSM 04.80 and GSM 03.38.
	
	Modes: GSM/WCDMA */
		KCapsPackedString=0x00000001
		};

/** Defines the USSD Messaging Type Capabilities.

Modes: GSM/WCDMA */
	enum TMobileUssdTypeCaps
		{
	/** Outgoing USSD messages are supported.
	
	Modes: GSM/WCDMA */
		KCapsMOUssd=0x00000001,
	/** Incoming USSD messages are supported.
	
	Modes: GSM/WCDMA */
		KCapsMTUssd=0x00000002
		};

	

	class TMobileUssdCapsV1 : public RMobilePhone::TMultimodeType
	/** Defines capabilities of USSD messaging. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileUssdCapsV1();
	/** Sum of TMobileUssdFormatCaps constants.
	
	Modes: GSM/WCDMA

	@see TMobileUssdFormatCaps */
		TUint32 iUssdFormat;
	/** Sum of TMobileUssdTypeCaps constants.
	
	Modes: GSM/WCDMA

	@see TMobileUssdTypeCaps */
		TUint32 iUssdTypes;
		};

/** A typedef'd packaged TMobileUssdCapsV1 for passing through a generic API member 
function. */
	typedef TPckg<TMobileUssdCapsV1> TMobileUssdCapsV1Pckg;

	IMPORT_C TInt GetCaps(TDes8& aCaps) const;

/** Defines the USSD Messaging Attributes.

Modes: GSM/WCDMA

@see TMobileUssdAttributesV1 */
	enum TMobileUssdAttributeFlags
		{
	/** The iFormat field is valid in the attribute class. */
		KUssdDataFormat = 0x00000001,
	/** The iType field is valid in the attribute class. */
		KUssdMessageType = 0x00000002,
	/** The iDcs field is valid in the attribute class. */
		KUssdMessageDcs = 0x00000004
		};

/** Defines the USSD Data Formats.

Modes: Common */
	enum TMobileUssdDataFormat
		{
	/** The message data format is unspecified.
	
	Modes: Common */
		EFormatUnspecified,
	/** The message data format complies to a USSD coded as 160 octets as defined for 
	a ussd-String within GSM 04.80 and GSM 03.38.
	
	Modes: GSM/WCDMA */
		EFormatPackedString
		};

/** Defines the USSD Message Types.

Modes: GSM/WCDMA */
	enum TMobileUssdMessageType
		{
	/** Message is an unknown type. */
		EUssdUnknown,
	/** Message is a mobile originated USSD request. The MS expects the network to 
	send a USSD MT reply. */
		EUssdMORequest,
	/** Message is a reply to a previously received network initiated USSD request. 
	It is a USSD MO reply. */
		EUssdMOReply,
	/** Message is a one-off network initiated USSD notification. The network expects the MS to
	send a USSD MO acknowledgement with empty message content. */
		EUssdMTNotify,
	/** Message is a network initiated USSD request. The network expects
	the MS to send a USSD MO reply. */
		EUssdMTRequest,
	/** Message is a network initiated reply to a previously sent MO USSD request. */
		EUssdMTReply,
	/** For acknowledging MT USSD notifications (empty message content). */
		EUssdMOAcknowledgement
		};

	

	class TMobileUssdAttributesV1 : public RMobilePhone::TMultimodeType
	/** Defines attributes of a USSD message. 
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileUssdAttributesV1();
	public:
	/** The TMobileUssdAttributeFlags bit-mask flags indicating which attributes are
	present in this instance.
	
	Modes: GSM/WCDMA

	@see TMobileUssdAttributeFlags */
		TUint32 iFlags;
	/** Format of the message data buffer.
	
	Modes: GSM/WCDMA
	
	@see TMobileUssdDataFormat */
		TMobileUssdDataFormat iFormat;
	/** The type of USSD message.
	
	Modes: GSM/WCDMA
	
	@see TMobileUssdMessageType */
		TMobileUssdMessageType iType;
	/** The Data Coding Scheme of the USSD message.
	
	Modes: GSM/WCDMA */
		TUint8 iDcs;
		};
	
/** A typedef'd packaged TMobileUssdAttributesV1 for passing through a generic 
API member function. */
	typedef TPckg<TMobileUssdAttributesV1> TMobileUssdAttributesV1Pckg;

	/***********************************************************************************/
	//
	// Receiving USSD messages
 	//
	/***********************************************************************************/

	enum 
		{
		KGsmUssdDataSize = 160
		};

/** A typedef'd buffer to hold the message data. */
	typedef TBuf8<KGsmUssdDataSize> TGsmUssdMessageData;

	IMPORT_C void ReceiveMessage(TRequestStatus& aReqStatus, TDes8& aMsgData, TDes8& aMsgAttributes) const;

	/***********************************************************************************/
	//
	// Sending USSD messages
	//
	/***********************************************************************************/

	IMPORT_C void SendMessage(TRequestStatus& aReqStatus, const TDesC8& aMsgData, const TDesC8& aMsgAttributes) const;
	IMPORT_C void SendMessageNoFdnCheck(TRequestStatus& aReqStatus, const TDesC8& aMsgData, const TDesC8& aMsgAttributes) const;
	
	IMPORT_C void SendRelease(TRequestStatus& aReqStatus, TDes8& aReturnResult) const;
	IMPORT_C void NotifyNetworkRelease(TRequestStatus& aReqStatus, TDes8& aReturnResult) const;
	IMPORT_C void NotifyNetworkRelease(TRequestStatus& aReqStatus, TDes8& aMsgData, TDes8& aMsgAttributes) const;

private:
	RMobileUssdMessaging(const RMobileUssdMessaging&);
	CUssdMessagingPtrHolder* iUssdMessagingPtrHolder;
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};



/*********************************************************/
//
// SMS Message Storage (RMobileSmsStore)
//
/*********************************************************/



class CSmsStorePtrHolder;
class CMobilePhoneSmsList;
class RMobileSmsStore : public RMobilePhoneStore
/** Provides client access to SMS storage functionality provided by TSY.
@publishedPartner
@released
*/
	{
public:

	IMPORT_C RMobileSmsStore();
	IMPORT_C TInt Open(RMobileSmsMessaging& aMessaging, const TDesC& aStoreName);
	IMPORT_C void Close();

/** Defines the SMS Store Capabilities.

Modes: Common */
	enum TMobileSmsStoreCaps
		{
	/** The store contains unread, incoming SMS entries.
	
	Modes: Common */
		KCapsUnreadMessages = 0x00000001,
	/** The store contains read, incoming SMS entries.
	
	Modes: Common */
		KCapsReadMessages = 0x00000002,
	/** The store contains sent SMS entries.
	
	Modes: Common */
		KCapsSentMessages = 0x00000004,
	/** The store contains un sent SMS entries. */
		KCapsUnsentMessages = 0x00000008,
	/** The store contains GSM SMS message entries â€“ so TMobileGsmSmsEntryV1 class 
	should be used.
	
	Modes: GSM/WCDMA */
		KCapsGsmMessages = 0x00000010,
	/** The store contains CDMA SMS message entries â€“ so TMobileCdmaSmsEntryV1 class 
	should be used.
	
	Modes: CDMA */
		KCapsCdmaMessages = 0x00000020
		};

/** Defines contents of a fixed-size, stored SMS entry.

Modes: Common */
	enum TMobileSmsStoreStatus
		{
	/** The status of the SMS is unknown. */
		EStoredMessageUnknownStatus,
	/** The SMS is stored phone-side. It is an incoming message that has not been read 
	yet. */
		EStoredMessageUnread,
	/** The SMS is stored phone-side. It is an incoming message that has already been 
	read. */
		EStoredMessageRead,
	/** The SMS is stored phone-side. It is an outgoing message that has not been sent 
	yet. */
		EStoredMessageUnsent,
	/** The SMS is stored phone-side. It is an outgoing message that has already been 
	sent but a delivery/status report has either not been received yet or was 
	not requested in the first place. */
		EStoredMessageSent,
	/** The SMS is stored phone-side. It is an outgoing message that has already been 
	sent and a delivery/status report has been received */
		EStoredMessageDelivered
		};

	//
	// Enum used by TSY to distinguish which SMS entry class is used by client
	//

/** Used by TSY to distinguish which SMS entry class is used by client. */
	enum TMobileSmsEntryExtensionId
		{
	/** Type is unknown. */
		KETelMobileSmsEntryV1=KETelExtMultimodeV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileGsmSmsEntryV1.
	
	Also used to indicate that GSM SMS entries will be retrieved by CRetrieveMobilePhoneSmsList. */
		KETelMobileGsmSmsEntryV1,
	/** The iExtensionId contents indicate that the packaged class is a TMobileCdmaSmsEntryV1.
	
	Also used to indicate that CDMA SMS entries will be retrieved by CRetrieveMobilePhoneSmsList. */
		KETelMobileCdmaSmsEntryV1
		};

	class TMobileSmsEntryV1 : public RMobilePhoneStore::TMobilePhoneStoreEntryV1
	/** Defines contents of a fixed-size, stored SMS entry.
	@publishedPartner
	@released 
	*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	protected:
		TMobileSmsEntryV1();
	public:
	/** The status of the stored message.
	
	Modes: Common
	
	@see TMobileSmsStoreStatus */
		TMobileSmsStoreStatus	iMsgStatus;	
		};

/** A typedef'd packaged TMobileSmsEntryV1 for passing through a generic API 
member function. */
	typedef TPckg<TMobileSmsEntryV1> TMobileSmsEntryV1Pckg;
	
	class TMobileGsmSmsEntryV1 : public TMobileSmsEntryV1
/** Defines contents of a fixed-size, stored GSM SMS entry.
@publishedPartner
@released */
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobileGsmSmsEntryV1();
	public:
	/** The service centre to use (or used) for the message.
	
	Modes: GSM/WCDMA
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iServiceCentre;
	/** The GSM 03.40 TPDU.
	
	Modes: GSM/WCDMA
	
	@see RMobileSmsMessaging::TMobileSmsGsmTpdu */
		RMobileSmsMessaging::TMobileSmsGsmTpdu	iMsgData;	
		};

/** A typedef'd packaged TMobileGsmSmsEntryV1 for passing through a generic API 
member function. */
	typedef TPckg<TMobileGsmSmsEntryV1> TMobileGsmSmsEntryV1Pckg;

	class TMobileCdmaSmsEntryV1 : public TMobileSmsEntryV1
	/** Defines contents of a fixed-size, stored CDMA SMS entry. 
	@publishedPartner
	@released
	*/
		{
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
		IMPORT_C TMobileCdmaSmsEntryV1();
	public:
	/** The teleservice identifier of the stored message.
	
	Modes: CDMA */
		TInt iTeleservice;
	/** The service category of the stored message.
	
	Modes: CDMA */
		TInt iServiceCategory;
	/** The remote party (destination or originator) of the stored message.
	
	Modes: CDMA
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iRemoteParty;
	/** The teleservice layer bearer data of the stored message.
	
	Modes: CDMA
	
	@see RMobileSmsMessaging::TMobileSmsCdmaTpdu */
		RMobileSmsMessaging::TMobileSmsCdmaTpdu iMsgData;	
		};

/** A typedef'd packaged TMobileCdmaSmsEntryV1 for passing through a generic API 
member function. */
	typedef TPckg<TMobileCdmaSmsEntryV1> TMobileCdmaSmsEntryV1Pckg;

protected:
	IMPORT_C void ConstructL();
private:
	RMobileSmsStore(const RMobileSmsStore&);
	};

/*********************************************************/
//
// NAM Storage (RMobileNamStore)
//
/*********************************************************/



class CNamStorePtrHolder;
class CMobilePhoneNamList;
class CMobilePhoneNamListV4;

class RMobileNamStore : public RMobilePhoneStore
/**
Provides client access to NAM storage functionality provided by TSY

*/
	{
public:
	IMPORT_C RMobileNamStore();
	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();



	class TMobileNamStoreInfoV1 : public RMobilePhoneStore::TMobilePhoneStoreInfoV1
	/**
	Defines information about a NAM store
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileNamStoreInfoV1();
	public:
	/** The number of enabled NAMs within the NAM store.
	
	Modes: CDMA */
		TInt iNamCount;
	/** The index of the NAM that is currently the active NAM, will be between 0 and 
	iNamCount-1.
	
	Modes: CDMA */
		TInt iActiveNam;
		};

/** A typedef'd packaged TMobileNamStoreInfoV1 for passing through a generic API 
member function. */
	typedef TPckg<TMobileNamStoreInfoV1> TMobileNamStoreInfoV1Pckg;

	IMPORT_C void SetActiveNam(TRequestStatus& aReqStatus, TInt aNamId) const;

	enum
		{
		/* The original maximum NAM parameter size for a TMobileNamEntryV1 */
		KMaxNamParamSize = 64,
		/* Updated maximum NAM parameter size for TMobileNamEntryV4 */
		KMaxNamParamSizeV4 = 256
		};

	class TMobileNamEntryV1 : public RMobilePhoneStore::TMobilePhoneStoreEntryV1
	/**
	Defines contents of a NAM store entry
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileNamEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** The NAM that is to be accessed, will be between 0 and TMobileNamStoreInfoV1::iNamCount-1.
	
	Modes: CDMA */
		TInt iNamId;
	/** The identifier of the NAM parameter to be accessed.
	
	TSY must define values of parameter identifiers.
	
	Modes: CDMA */
		TInt iParamIdentifier;
	/** The data contents of the selected parameter.
	
	Modes: CDMA
	
	@see KMaxNamParamSize */
		TBuf8<KMaxNamParamSize> iData;
		};

	/** A typedef'd packaged TMobileNamEntryV1 for passing through a generic API member 
	function. */
	typedef TPckg<TMobileNamEntryV1> TMobileNamEntryV1Pckg;

	/** Enumeration for the standard NAM parameters (see 3GPP2 C.S0005-A appendix F.3)
	Modes: CDMA */
	enum TStandardNamParameters
		{
		/** The 64-bit pattern stored in the Mobile Station and 
			Home Location Register/Authentication Centre used to generate/update the 
			mobile station’s Shared Secret Data
			Corresponds to NAM Indicator 'A_KEY' */
		EAKey,
		/** 64-bit key used for authentication
			Corresponds to NAM Indicator 'SSD_A(s-p)' */
		ESharedSecretDataA,
		/** 64-bit key used as input to generate encryption mask and long code
			Corresponds to NAM Indicator 'SSD_B(s-p)' */
		ESharedSecretDataB,
		/** Modulo-64 event counter maintained by the mobile station and Authentication Center 
			used for clone detection
			Corresponds to NAM Indicator 'COUNT(s-p)' */
		EParameterUpdateReceivedCount,
		/** Class of the International Mobile Station Identity (IMSI) containing a MIN as 
			the lower 10 digits 
			Corresponds to NAM Indicator 'IMSI_M_CLASS(p)' */
		EMinBasedImsiClass,
		/** The class of the International Mobile Station Identity (IMSI) not containing a MIN as 
			the lower 10 digits 
			Corresponds to NAM Indicator 'IMSI_T_CLASS(p)' */
		ETrueImsiClass,
		/** 34-bit number derived from the IMSI M used as input for authentication
			Corresponds to NAM Indicator 'IMSI_M_S(p)' */
		EMinBasedImsiS,
		/** 34-bit number derived from the IMSI T used as input for authentication
			Corresponds to NAM Indicator 'IMSI_T_S(p)' */
		ETrueImsiS,
		/** Number of digits in the IMSI M minus 4
			Corresponds to NAM Indicator 'IMSI_M_ADDR_NUM(p)' */
		EMinBasedImsiAddressNum,
		/** The number of digits in the IMSI T minus 4
			Corresponds to NAM Indicator 'IMSI_T_ADDR_NUM(p)' */
		ETrueImsiAddressNum,
		/** The 11th and 12th digits in the IMSI M
			Corresponds to NAM Indicator 'IMSI_M_11_12(p)' */
		EMinBasedImsiDigits11and12,
		/** The 11th and 12th digits in the IMSI T
			Corresponds to NAM Indicator 'IMSI_T_11_12(p)' */
		ETrueImsiDigits11and12,
		/** The country code for the IMSI M
			Corresponds to NAM Indicator 'MCC_M(p)' */
		EMinBasedMobileCountryCode,
		/** The country code for the IMSI T
			Corresponds to NAM Indicator 'MCC_T(p)' */
		ETrueMobileCountryCode,
		/** Up to 15 digit dialable number associated with the mobile station through a service 
			subscription
			Corresponds to NAM Indicator 'MDN(p)' */
		EMobileDirectoryNumber,
		/** 4-bit number giving the length of the assigning Temporary Mobile Station Identity (TMSI) zone 
			(can range from 1 to 8 octets)
			Corresponds to NAM Indicator 'ASSIGNING_TMSI_ZONE_LEN(s-p)' */
		EAssigningTmsiZoneLen,
		/** Temporary Mobile Station Identity (TMSI) zone is an arbitrary set of base stations 
			for the administrative assignment of TMSI
			Corresponds to NAM Indicator 'ASSIGNING_TMSI_ZONE(s-p)' */
		EAssigningTmsiZone,
		/** The uniquely assigned number to a mobile station inside a TMSI zone
			Corresponds to NAM Indicator 'TMSI_CODE(s-p)' */
		ETmsiCode,
		/** The expiration time used to automatically delete the assigned TMSI
			Corresponds to NAM Indicator 'TMSI_EXP_TIME(s-p)' */
		ETmsiExpTime,
		/** Mobile station's home System Id for 800MHz analog operation
			Corresponds to NAM Indicator 'HOME_SID(p)' */
		EHomeSystemIdAnalog,
		/** Mobile station's home System Id
			Corresponds to NAM Indicator 'SID(p)' */
		EHomeSystemId,
		/** Mobile station's home Network Id
			Corresponds to NAM Indicator 'NID(p)' */
		EHomeNetworkId,
		/** Mobile station is configured to receive mobile station terminated calls when 
			using a home (SID, NID) pair
			Corresponds to NAM Indicator 'MOB_TERM_HOME(p)' */
		EReceiveCallsHome,
		/** The mobile station is configured to receive mobile station terminated calls when 
			it is a foreign SID roamer
			Corresponds to NAM Indicator 'MOB_TERM_FOR_SID(p)' */
		EReceiveCallsForeignSystem,
		/** The mobile station is configured to receive mobile station terminated calls when 
			it is a foreign NID roamer
			Corresponds to NAM Indicator 'MOB_TERM_FOR_NID(p)' */
		EReceiveCallsForeignNetwork,
		/**	A TSY may use this as the first TSY-defined non-standard NAM parameter */
		ENumStandardNamParameters
		};

	class TMobileNamEntryV4 : public RMobilePhoneStore::TMobilePhoneStoreEntryV1
	/**
	Defines contents of a NAM store entry

	The differences between the original TMobileNamEntryV1, and updated TMobileNamEntryV4 are:
	- the maximum mobile NAM parameter size is KMaxNamParamSize(64) for TMobileNamEntryV1
	  and KMaxNamParamSizeV4(256) for TMobileNamEntryV4
	- TMobileNamEntryV4 defines a set of standard NAM parameters for the iParamIdentifier as
	  described in 3GPP2 C.S0005-A appendix F.3
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileNamEntryV4();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** The NAM that is to be accessed, will be between 0 and TMobileNamStoreInfo::iNamCount-1.
	
	Modes: CDMA */
		TInt iNamId;

	/** The identifier of the NAM parameter to be accessed.
	iParamIdentifier will be a TStandardNamParameters value if a standard NAM parameter is being accessed, 
	however a TSY may support and define NAM parameters in addition to those given by TStandardNamParameters	
	Modes: CDMA */
		TInt iParamIdentifier;

	/** The data contents of the selected parameter.
	
	Modes: CDMA
	
	@see KMaxNamParamSizeV4 */
		TBuf8<KMaxNamParamSizeV4> iData;
		};

	/** A typedef'd packaged TMobileNamEntryV4 for passing through a generic API member 
	function. */
	typedef TPckg<TMobileNamEntryV4> TMobileNamEntryV4Pckg;

	IMPORT_C void StoreAllL(TRequestStatus& aReqStatus, TInt aNamId, CMobilePhoneNamList* aNamList) const;
	IMPORT_C void StoreAllL(TRequestStatus& aReqStatus, TInt aNamId, CMobilePhoneNamListV4* aNamList) const;

protected:
	IMPORT_C void ConstructL();
private:
	RMobileNamStore(const RMobileNamStore&);
	};


/*********************************************************/
//
// Own Number Storage (RMobileONStore)
//
/*********************************************************/



class CONStorePtrHolder;
class CMobilePhoneONList;
	
class RMobileONStore : public RMobilePhoneStore
/**
Provides client access to Own Number storage functionality provided by TSY

*/
	{
public:
	IMPORT_C RMobileONStore();
	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

	

	class TMobileONStoreInfoV1 : public RMobilePhoneStore::TMobilePhoneStoreInfoV1
	/**
	Defines information about an Own Number store
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileONStoreInfoV1();
	public:
	/** The maximum length of the own phone number can be. */
		TInt iNumberLen;
	/** The maximum length the text field can be. */
		TInt iTextLen;
		};

/** A typedef'd packaged TMobileONStoreInfoV1 for passing through a generic API 
member function. */
	typedef TPckg<TMobileONStoreInfoV1> TMobileONStoreInfoV1Pckg;

	enum
		{
		KOwnNumberTextSize = 20
		};

	

	class TMobileONEntryV1 : public RMobilePhoneStore::TMobilePhoneStoreEntryV1
	/**
	Defines contents of a Own Number store entry
	
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileONEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** Network mode. */
		RMobilePhone::TMobilePhoneNetworkMode iMode;
	/** Mobile call service type.
	
	@see RMobilePhone::TMobileService */
		RMobilePhone::TMobileService iService;
	/** Own number.
	
	@see RMobilePhone::TMobileAddress */
		RMobilePhone::TMobileAddress iNumber;
	/** The name-tag associated with own number (e.g. "Voice Number"). */
		TBuf<KOwnNumberTextSize> iText;
		};

/** A typedef'd packaged TMobileONEntryV1 for passing through a generic API member 
function. */
	typedef TPckg<TMobileONEntryV1> TMobileONEntryV1Pckg;

	IMPORT_C void StoreAllL(TRequestStatus& aReqStatus, CMobilePhoneONList* aONList) const;

protected:
	IMPORT_C void ConstructL();
private:
	RMobileONStore(const RMobileONStore&);
	};

/*********************************************************/
//
// Emergency Number Storage (RMobileENStore)
//
/*********************************************************/



class CMobilePhoneENList;

class RMobileENStore : public RMobilePhoneStore
/**
Provides client access to Emergency Number storage functionality provided by TSY

*/
	{
public:
	IMPORT_C RMobileENStore();
	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

	enum 
		{
		KEmergencyNumberSize  = 6,
		KEmergencyAlphaTagSize = 20
		};

/** Enumerated list of Emergency Number entries.

Mode: WCDMA */
	enum TMobilePhoneENServiceCategory
		{
	/** This number provides emergency care by the police department. */
		KServiceCatPolice =0x0001,
	/** This number provides emergency care by the ambulance department. */
		KServiceCatAmbulance =0x0002,
	/** This number provides emergency care by the fire brigade department. */
		KServiceCatFireBrigade =0x0004,
	/** This number provides emergency care by the marine guard department. */
		KServiceCatMarineGuard =0x0008,
	/** This number provides emergency care by the mountain rescue department. */
		KServiceCatMountainRescue =0x0010
		// Reserved types: 0x0020,0x0040,
		};

	

/** Buffer to hold the emergency number in. */
	typedef TBuf<KEmergencyNumberSize> TEmergencyNumber;

	class TMobileENEntryV1 : public RMobilePhoneStore::TMobilePhoneStoreEntryV1
	/**
	Defines contents of a Emergency Number store entry
	@publishedPartner
	@released
	*/
		{
	public:
		IMPORT_C TMobileENEntryV1();
	public:
		void InternalizeL(RReadStream& aStream);
		void ExternalizeL(RWriteStream& aStream) const;
	public:
	/** Indicates whether the emergency number is applicable in all situations (=EFalse) 
	or only when the MS is registered to a specific GSM or CDMA network (=ETrue). */
		TBool iNetworkSpecific;
	/** The network mode. Only applicable if iNetworkSpecific equals ETrue.

	Modes: Common
	
	@see RMobilePhone::TMobilePhoneNetworkMode */
		RMobilePhone::TMobilePhoneNetworkMode iMode;
	/** Country code. Only applicable if iNetworkSpecific equals ETrue.
	
	Modes: Common
	
	@see RMobilePhone::TMobilePhoneNetworkCountryCode */
		RMobilePhone::TMobilePhoneNetworkCountryCode iCountryCode;
	/** Network identity. Only applicable if iNetworkSpecific equals ETrue.
	
	Modes: Common
	
	@see RMobilePhone::TMobilePhoneNetworkIdentity */
		RMobilePhone::TMobilePhoneNetworkIdentity iIdentity;
	/** Emergency number.
	
	Modes: Common
	
	@see TEmergencyNumber */
		TEmergencyNumber             iNumber;
	/** Emergency call number type. It is used to display information about the dialed 
	emergency number (e.g. "Police", "Ambulance", "Fire brigade", etc.)
	
	Modes: WCDMA */
		TBuf<KEmergencyAlphaTagSize> iAlphaId;
		//TInt should map to TMobilePhoneENServiceCategory.
		//It was not changed to maintain source compatibility
		
	/** Emergency call type indicator, which contains information to be sent to the 
	network indicating the type of emergency call.
	
	The field is for future reference only and it is set to RFU (Reserved for
	Future Use) as it is currently not being used, as specified in section 4.2.21 
	TS 31.102 v3.3.0 Rel 99.
	
	Modes: WCDMA */
		TInt	                     iCallType; 
		};

	typedef TPckg<TMobileENEntryV1> TMobileENEntryV1Pckg;

protected:
	IMPORT_C void ConstructL();
private:
	RMobileENStore(const RMobileENStore&);
	};


/*********************************************************/
//
// RMobilePhoneBookStore 
//
/*********************************************************/



class CPhoneBookStorePtrHolder;
class CMobilePhoneBookList;

class RMobilePhoneBookStore : public RMobilePhoneStore
/** Provides member functions for clients to access phone 
books that are stored in ICC memory or in non-volatile memory on the phone 
itself. This sub-session and the member functions within this section must 
be supported if the TSY indicates that it supports the MobilePhonebookStore 
functional unit.
@publishedPartner
@released 
*/
	{
public:
	IMPORT_C RMobilePhoneBookStore();
	IMPORT_C TInt Open(RMobilePhone& aPhone, const TDesC& aStore);
	IMPORT_C TInt Open(RMobilePhone& aPhone, const TDesC& aStore, const TDesC& aMode);
	IMPORT_C void Close();

/** Describes the specialized phone book capabilities.

Modes: Common */
	enum TMobilePhoneBookCaps
		{
	/** New entries can only be written to (or deleted from) the phone book with the 
	PIN2 password or equivalent.
	
	Modes: Common */
		KCapsRestrictedWriteAccess = 0x00000001,
	/** The phonebook supports the second name field.
	
	Modes: WCDMA */
		KCapsSecondNameUsed        = 0x00000002,
	/** The phonebook supports the additional number (with optional Text, TON, NPI 
	and Bearer Capability) field.
	
	Modes: WCDMA */
		KCapsAdditionalNumUsed     = 0x00000004,
	/** The phonebook supports the group name field.
	
	Modes: WCDMA */
		KCapsGroupingUsed		   = 0x00000008,
	/** The phonebook supports entry control and hidden flag fields.

	Modes: WCDMA */
		KCapsEntryControlUsed      = 0x00000010,
	/** The phonebook supports the email address field.
	
	Modes: WCDMA */
		KCapsEmailAddressUsed      = 0x00000020,
	/** The phonebook supports the bearer capability IE field.
	
	Modes: WCDMA */
		KCapsBearerCapUsed		   = 0x00000040,
	/** The phonebook supports retrieval of the phonebook's PBID and Change Counter 
	- and for each entry its UID field.
	
	Modes: WCDMA */
		KCapsSynchronisationUsed   = 0x00000080
		};

/** Described the location of the phone book.

Modes: Common for all */
	enum TMobilePhoneBookLocation
		{
	/** The phonebook's location is unknown. */
		ELocationUnknown,
	/** The phonebook is located in ICC (SIM/R-UIM) memory. */
		ELocationIccMemory,
	/** The phonebook is located in Phone (ME) memory. */
		ELocationPhoneMemory,
	/** The phonebook is located in an external memory. */
		ELocationExternalMemory,
	/** The phonebook entries are dispersed over a combination of memory locations. */
		ELocationCombinedMemory
		};

	enum
		{
		KMaxPBIDSize=15
		};

/** Defines a modifiable buffer descriptor to contain the phone book identity. 
Used in TMobilePhoneBookInfoV1. */
	typedef TBuf8<KMaxPBIDSize> TMobilePhoneBookIdentity;

	

	class TMobilePhoneBookInfoV1 : public RMobilePhoneStore::TMobilePhoneStoreInfoV1
	/**
	Defines information about a Phonebook store.
	@publishedPartner
	@released
	*/
		{
	public:
	/** Trivial constructor. Initializes iMaxNumLength=-1; iMaxTextLength=-1; iLocation=ELocationUnknown; 
	iChangeCounter=0; iExtensionId=KETelMobilePhonebookStoreV1; */
		IMPORT_C TMobilePhoneBookInfoV1();
	public:
	/** The maximum number of characters for the number in a phonebook entry.
	
	Modes: Common */
		TInt    iMaxNumLength;
	/** The maximum number of characters for the text tag in a phonebook entry.
	
	Modes: Common */
		TInt    iMaxTextLength;
	/** The memory location of this phonebook.
	
	Modes: Common
	
	@see TMobilePhoneBookLocation */
		TMobilePhoneBookLocation iLocation;
	/** The contents of the Change Counter file in a USIM phonebook.
	
	Modes: WCDMA */
		TUint16 iChangeCounter;
	/** A unique identity for this type of phonebook.
	
	If this is a SIM or R-UIM phonebook then it will equal the ICCID of the card.
	
	If this is a USIM phonebook then it will equal the PBID of the phonebook. 
	
	Modes: Common
	
	@see TMobilePhoneBookIdentity */
		TMobilePhoneBookIdentity iIdentity; 
		};

/** Packages the TMobilePhoneBookInfoV1 into a TMobilePhoneBookInfoV1Pckg. */
	typedef TPckg<TMobilePhoneBookInfoV1> TMobilePhoneBookInfoV1Pckg;

	
	class TMobilePhoneBookInfoV2 : public TMobilePhoneBookInfoV1
/** Defines information about a Phonebook store for version v2.0 of the API.
@publishedPartner
@released */
		{
	public:
		IMPORT_C TMobilePhoneBookInfoV2();
	public:
	/** The type of the phonebook which relates to its location (ICC/UICC/CDMA).
	
	Mode: Common */
		TName iPhBkMode; 
		};

/** Packages the TMobilePhoneBookInfoV2 into a TMobilePhoneBookInfoV1Pckg. */
	typedef TPckg<TMobilePhoneBookInfoV2> TMobilePhoneBookInfoV2Pckg;


	/** Defines information about a Phonebook store for version v5.0 of the API.

	Extends the v2.0 API to allow additional information about the phonebook
	(Maximum number of second name fields, Maximum number of additional number fields,
	Maximum number of additional group name fields, Maximum number of email address fields)
	to be retieved where available. 

	@publishedPartner
	@released*/
	class TMobilePhoneBookInfoV5 : public TMobilePhoneBookInfoV2
		{
	public:
		IMPORT_C TMobilePhoneBookInfoV5();
	public:
		/** The maximum number of Second Name fields that can be used. */
		TInt iMaxSecondNames;
		
		/** The maximum text length for Second Name fields. */
		TInt iMaxTextLengthSecondName;

		/** The maximum number of additional number fields that can be used. */
		TInt iMaxAdditionalNumbers;
		
		/** The maximum number length for Additional Number fields. */
		TInt iMaxNumLengthAdditionalNumber;
		
		/** The maximum text length for Additonal Number fields. */
		TInt iMaxTextLengthAdditionalNumber;

		/** The maximum number of additional Group Name fields that can be used. */
		TInt iMaxGroupNames;
		
		/** The maximum text length for Group Name fields. */
		TInt iMaxTextLengthGroupName;
		
		/** The maximum number of additional E-Mail address fields that can be used. */
		TInt iMaxEmailAddr;
		
		/** The maximum text length for Email Address fields. */
		TInt iMaxTextLengthEmailAddr;
		};

	/** Packages the TMobilePhoneBookInfoV5 into a TMobilePhoneBookInfoV5Pckg. */
	typedef TPckg<TMobilePhoneBookInfoV5> TMobilePhoneBookInfoV5Pckg;


	// check these fields - not sure all are correct
/** The following Tag IDs are used to encode/decode the phonebook entries to/from 
the TLV format. Each field will have a unique identifier and will be followed 
by the field length. The type of data associated with the field is also specified 
below. 

Some fields do not have any data and just serve as separators within the buffer 
- in these cases the Data Type column is set to not applicable (n/a).

Modes: Common */
	enum TMobilePBFieldTags
		{
	/** Tag id for the beginning of a new phonebook entry.
	
	Data type: n/a.
	
	Modes: Common */
		ETagPBNewEntry		=0xA0,
	/** Tag id for the Unique ID field.
	
	Data type: TUint16

	Modes: WCDMA */
		ETagPBUniqueId		=0xB0,
	/** Tag id for the Index within the ADN record.
	
	Data type: TUint16

	Modes: Common */
		ETagPBAdnIndex		=0xC0,
	/** Tag id for a Text field within the ADN/ANR record.
	
	Data type: TDes16
	
	Modes: Common */
		ETagPBText			=0xC1,
	/** Tag id for a Number field within the ADN/ANR record.
	
	Data type: TDes16
	
	Modes: Common */
		ETagPBNumber		=0xC2,
	/** Tag id for a TON/NPI byte within the ADN/ANR record.
	
	Data type: TUint8
	
	Modes: Common */
		ETagPBTonNpi		=0xC3,
	/** Tag id for a Bearer Capability IE associated to the ADN/ANR record.
	
	Data type: TDes8
	
	Modes: GSM/WCDMA */
		ETagPBBearerCap		=0xC4,
	/** Tag id for the beginning of an Additional Number entry within the phonebook 
	entry.
	
	Data type: n/a
	
	Modes: WCDMA */
		ETagPBAnrStart		=0xC5,
	/** Tag id for the Second Name associated to the ADN record.
	
	Data type: TDes16
	
	Modes: WCDMA */
		ETagPBSecondName	=0xC6,
	/** Tag id for a Group Name associated to the ADN record.
	
	Data type:TDes16
	
	Modes: WCDMA */
		ETagPBGroupName		=0xC7,
	/** Tag id for an Email Address associated to the ADN record.
	
	Data type: TDes16
	
	Modes: WCDMA */
		ETagPBEmailAddress	=0xC8,
	/** Tag id for the Entry Control byte associated to the ADN record.
	
	Data type: TUint8
	
	Modes: WCDMA */
		ETagPBEntryControl	=0xC9,
	/** Tag id for the Hidden Information byte associated to the ADN record.
	
	Data type: TUint8
	
	Modes: WCDMA */
		ETagPBHiddenInfo	=0xCA,
		ETagPBDateTime		=0xCB,
		ETagPBDuration		=0xCC,
		ETagPBCallStatus	=0xCD,
		ETagPBEntryStatus	=0xCE
		};


	// API/TSY internal type
	struct TPBIndexAndNumEntries
/** A structure to hold the phone book index and number of entries. */
		{
	/** Index for the phone book. */
		TInt iIndex;
		TInt iNumSlots;
		};

	IMPORT_C void Read(TRequestStatus& aReqStatus, TInt aIndex, TInt aNumSlots, TDes8& aPBData) const;
	IMPORT_C void Write(TRequestStatus& aReqStatus, const TDesC8& aPBData, TInt& aIndex) const;

protected:
	IMPORT_C void ConstructL();
private:
	RMobilePhoneBookStore(const RMobilePhoneBookStore&);
	};

/*********************************************************/
//
// RMobileConferenceCall
//
/*********************************************************/



class CMobileConferenceCallPtrHolder;

class RMobileConferenceCall : public RTelSubSessionBase
/** Provides access to conference call functionality provided by TSY.

Conference calls allow users to conduct multi-connection voice calls, for example
simultaneous communication to more than one remote party. All participants 
within a conference call can hear and speak to each other. There is a controlling 
party that initiates and manages the conference.

Conference calling is possible in both GSM and CDMA mode and the actions to 
initiate a 3-way conference are the same in either mode. However, GSM conference 
calls offer more functionality and the number of remote parties is limited 
in CDMA mode to 2 and in GSM mode to 5.

The Multimode ETel API uses a new sub-session called RMobileConferenceCall 
as a model for a conference call. The conference call object will be an aggregation 
of all the RMobileCall objects that are part of the conference call. It will 
be possible for clients to manipulate both the conference call as a whole 
and individual calls within a conference call depending on the dynamic capabilities 
of each of these objects.

Please note that RMobileConferenceCall is replacing the RCallGroup abstraction 
used in the GSM API. This was an optimisation decision. The call group abstraction 
placed a large burden on a TSY to create call groups, monitor the calls in 
each group and trigger notification when calls were added or moved, probably 
even when a conference call was not ongoing. Clients will probably only open 
a RMobileConferenceCall when the user has decided to make a conference call 
and by having just one object replace three call groups it will also reduce 
the number of notifications that would trigger in response to conference call 
events. With a view to the future, without call groups there are also no longer 
any restrictions to the allowed types of active calls (simultaneous, separate 
voice and data calls are possible).

The methods within this section must be supported if the TSY supports MobileConferenceCall 
functional unit. 

*/
	{
public:
	IMPORT_C RMobileConferenceCall();
	IMPORT_C TInt Open(RMobilePhone& aPhone);
	IMPORT_C void Close();

/** Conference call capabilities. */
	enum TMobileConferenceCallCaps
		{
	/** Indicates that a conference call can be created. */
		KCapsCreate = 0x00000001,
	/** Indicates that a conference call can be terminated. */
		KCapsHangUp = 0x00000002,
	/** Indicates that a conference call exists and can be swapped to the opposite 
	state (active or hold). */
		KCapsSwap = 0x00000004
		};

	IMPORT_C TInt GetCaps(TUint32& aCaps) const;
	IMPORT_C void NotifyCapsChange(TRequestStatus& aReqStatus, TUint32& aCaps) const;

	IMPORT_C void CreateConference(TRequestStatus& aReqStatus) const;
	IMPORT_C void AddCall(TRequestStatus& aReqStatus, const TName& aCallName) const;
	IMPORT_C void Swap(TRequestStatus& aReqStatus) const;
	IMPORT_C void HangUp(TRequestStatus& aReqStatus) const;
	IMPORT_C TInt EnumerateCalls(TInt& aCount) const;
	IMPORT_C TInt GetMobileCallInfo(TInt aIndex, TDes8& aCallInfo) const;

/** Conference call status. */
	enum TMobileConferenceStatus
		{
	/** The conference call is in the idle state. */
		EConferenceIdle,
	/** The conference call is in the active, connected state. */
		EConferenceActive,
	/** The conference call is in the held, connected state. */
		EConferenceHold
		};
	
	IMPORT_C TInt GetConferenceStatus(TMobileConferenceStatus& aStatus) const;
	IMPORT_C void NotifyConferenceStatusChange(TRequestStatus& aReqStatus, TMobileConferenceStatus& aStatus) const;

/** Conference events. */
	enum TMobileConferenceEvent
		{
	/** A call has been added to the conference. */
		EConferenceCallAdded,		// Name of the call added returned in aCallName
	/** A call has been removed from the conference. */
		EConferenceCallRemoved,		// Name of the call terminated returned in aCallName
	/** Names of the two calls used to build the conference call returned in aCallName. */
		EConferenceBuilt,		// Names of the two calls used to build the conference call returned in aCallName
	/** No name provided */
		EConferenceTerminated,	// No name provided
	/** No name provided. */
		EConferenceSwapped,		// No name provided
	/** Name of the call being seperated. */
		EConferenceSplit		// Name of the call being seperated
		};

	IMPORT_C void NotifyConferenceEvent(TRequestStatus& aReqStatus, TMobileConferenceEvent& aEvent, TName& aCallName) const;

private:
	CMobileConferenceCallPtrHolder* iMmPtrHolder;
	RMobileConferenceCall(const RMobileConferenceCall&);
protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();
	};


/////////////////////////////////////////////////////////////////////////////////////
//
// EAP-SIM Authentication functional unit
//
/////////////////////////////////////////////////////////////////////////////////////

class CMobileSmartCardEapPtrHolder;

/**
This sub-session opens under RMobilePhone.

RMobileSmartCardEap provides the client with access to a Smart Card
Application's EAP-capability (if one exists).

(See ETSI TS 102.310 v6.2.0 and RFC3748)

To submit authentication challenges or requests, a client must use
CAsyncSmartCardEapAuthentication in conjunction with this sub-session.

@see CAsyncSmartCardEapAuthentication
@publishedPartner
@prototype
*/
class RMobileSmartCardEap : public RTelSubSessionBase
	{
	friend class CAsyncSmartCardEapAuthentication;

public:
	/**
	Class encapsulates EAP request packet data for authentication.

	@see CAsyncSmartCardEapAuthentication

	@publishedPartner
	@prototype
	*/
	class CEapAuthenticateRequestDataV6 : public CBase
		{
	public:
		IMPORT_C static CEapAuthenticateRequestDataV6* NewL();
		IMPORT_C virtual void ExternalizeL(TPtr8& aBuffer);
		IMPORT_C virtual void InternalizeL(const TDesC8& aBuffer);
		IMPORT_C TUint VersionId() const;
		IMPORT_C TPtr8 GetEapReqPacket() const;
		IMPORT_C void SetEapReqPacketL(const TDesC8& aData);
		IMPORT_C ~CEapAuthenticateRequestDataV6();

	private:
		CEapAuthenticateRequestDataV6();
		void ConstructL();

	protected:
		/**
		ETelMM's supported version.
		*/
		TUint iVersionId;

	public:
		/**
		EAP-request packet in a flat buffer.
		*/
		CBufFlat* iEapReqPacket;
		};

	IMPORT_C RMobileSmartCardEap();

	/**
	EAP types are represented by one byte for standard EAP methods, and
	eight bytes for extended methods.  Each byte specified in the
	TEapType buffer should represent one semi-octet.  Therefore, a
	maximum of 16-chars are needed for representing any possible EAP
	type.  (See section 5.2 of ETSI TS 102.310 v6.2.0.)

	@see RMobileSmartCardEap::TEapType

	@publishedPartner
	@prototype
	*/
	enum { KEapTypeSize = 16 };

	/**
	A typedef'd buffer to hold the EAP type for the subsequent
	authentication that will be carried out on the Smart Card
	Application.

	The value specified must correspond to the pre-allocated type
	identifiers for various EAPs (see
	http://www.iana.org/assignments/eap-numbers).  Some known values
	are given in etelmm.h.

	The type must be specified in hexadecimal format, where each
	character represents one semi-octet.

	@see KETelSmartCardEapTypeMD5
	@see KETelSmartCardEapTypeTLS
	@see KETelSmartCardEapTypeSIM
	@see KETelSmartCardEapTypeAKA
	@see KETelSmartCardEapTypeTTLS
	@see RMobileSmartCardEap::Open()

	@publishedPartner
	@prototype
	*/
	typedef TBuf8<KEapTypeSize> TEapType;

	IMPORT_C TInt Open(RMobilePhone& aPhone, const RMobilePhone::TAID& aAID, const TEapType& aEapType);
	IMPORT_C void InitialiseEapMethod(TRequestStatus& aReqStatus);
	IMPORT_C void Close();

	/**
	Authentication status of the EAP supporting UICC application (See
	section 7.2 of ETSI TS 102.310 v6.2.0).  One of these values is
	returned on completion of an
	RMobileSmartCardEap::GetAuthenticationStatus() request.

	@see RMobileSmartCardEap::GetAuthenticationStatus()

	@publishedPartner
	@prototype
	*/
	enum TEapAuthStatus
		{
		/**
		No authentication started
		*/
		ENoAuthStarted,    // 0
		/**
		Authenticating
		*/
		EAuthenticating,   // 1
		/**
		Authentication complete
		*/
		EAuthenticated,    // 2
		/**
		Held (authentication failure)
		*/
		EHeld              // 3
		};

	IMPORT_C void GetAuthenticationStatus(TRequestStatus& aReqStatus, TEapAuthStatus& aAuthStatus);

	/**
	TEapUserIdType should be used to request an identity from EF_PUId
	or EF_Ps, when making an RMobileSmartCardEap::GetUserIdentity()
	request.
	(See sections 7.3 and 7.4, respectively, of ETSI TS	102.310 v6.2.0,
	and RFC2486 - The Network Access Identifier).

	@see RMobileSmartCardEap::GetUserIdentity()
	@see RMobileSmartCardEap::TEapUserIdentityV6

	@publishedPartner
	@prototype
	*/
	enum TEapUserIdType
		{
		/** Identity is permanent type */
		EPermanentIdentity,   // 0
		/** Identity is pseudonym type */
		EPseudonymIdentity    // 1
		};

	/**
	Maximum permitted size of identity data.
	*/
	enum { KEapIdentityMaxSize = 255 };

	/**
	EAP User Identity data.  Ids are stored in EF_PUId or EF_Ps
	(specified in sections 7.3 and 7.4, respectively, of ETSI TS
	102.310 v6.2.0).

	@see RMobileSmartCardEap::GetUserIdentity()

	@publishedPartner
	@prototype
	*/
	class TEapUserIdentityV6 : public RMobilePhone::TMultimodeType
		{
	public:
		IMPORT_C TEapUserIdentityV6();
	public:
		/**
		EAP-IDENTITY Data.
		*/
		TBuf8<KEapIdentityMaxSize> iEapId;
		};

	/**
	A typedef'd packaged TEapUserIdentityV6 for passing through a
	generic API method.

	@publishedPartner
	@prototype
	*/
	typedef TPckg<TEapUserIdentityV6> TEapUserIdentityV6Pckg;

	IMPORT_C void GetUserIdentity(TRequestStatus& aReqStatus,
	                              TEapUserIdType aRequestedIdType,
	                              TDes8& aUserId);

	/**
	TEapKeyV6 should be used to request one of (currently) two keys
	available on the EF_EAPKEYS of the UICC application (see section
	7.1 of ETSI TS 102.310 v6.2.0).  This enumeration type should be
	used in RMobileSmartCardEap::GetEapKey() to specify the key to be
	retrieved.

	@see RMobileSmartCardEap::TEapKeyV6
	@see RMobileSmartCardEap::GetEapKey()

	@publishedPartner
	@prototype
	*/
	enum TEapKeyTag
		{
		/**
		Used to request Master Session Key.
		*/
		EEapKeyMSK =  0x80,
		/**
		Used to request Extended Master Session Key.
		*/
		EEapKeyEMSK = 0x81
		};

	/**
	Maximum size of an EAP Key stored on the DF_EAP's EF_EAPKEYS.
	255 as each key has a length that can be specified by exactly one
	byte (see section 7.1 of ETSI TS 102.310 v6.2.0).

	@publishedPartner
	@prototype
	*/
	enum { KEapKeyMaxSize = 255 };

	/** 
	EAP authentication key data.

	@see RMobileSmartCardEap::GetEapKey()

	@publishedPartner
	@prototype
	*/
	class TEapKeyV6 : public RMobilePhone::TMultimodeType
		{
	public:
		IMPORT_C TEapKeyV6();
	public:
		/**
		EAP-KEY Data.
		*/
		TBuf8<KEapKeyMaxSize> iEapKey;
		};

	/**
	A typedef'd packaged TEapKeyV6 for passing through a generic API
	method.

	@publishedPartner
	@prototype
	*/
	typedef TPckg<TEapKeyV6> TEapKeyV6Pckg;

	IMPORT_C void GetEapKey(TRequestStatus& aReqStatus, const TEapKeyTag aRequestedKey, TDes8& aKey);

	/**
	Status of the DF_EAP this subsession refers to.  The status is
	basically an indication of whether the DF is in use by another sub-
	session client instance.

	NotifyEapMethodAccessStatusChange() will give a notification when
	the status changes.

	Status will change when the first client calls
	InitialiseEapMethod() on this sub-session.  When the same client
	calls ReleaseEapMethod() (or Close()), the status will change
	again.  This allows mutually exclusive access to the DF_EAP.  All
	other RMobileSmartCardEap hanles will get an error if they attempt
	to make requests that access the same DF_EAP.

	@see RMobileSmartCardEap::NotifyEapMethodAccessStatusChange()
	@see RMobileSmartCardEap::ReleaseEapMethod()
	@see RMobileSmartCardEap::InitialiseEapMethod()

	@publishedPartner
	@prototype
	*/
	enum TEapMethodAccessStatus
		{
		/**
		AID/DF_EAP has been reset, and the DF_EAP has not been
		initialised by any other instance of RMobileSmartCardEap.
		*/
		EEapMethodAvailable,
		/**
		Another instance of RMobileSmartCardEap has initialised first
		and taken ownership of the DF_EAP.  The DF_EAP is currently
		active and EAP requests can be made.
		*/
		EEapMethodInUseApplicationActive,
		/**
		This instance of RMobileSmartCardEap still owns the lock on the
		DF_EAP, but the application has been deactivated elsewhere.
		The client should re-initialise before making further EAP
		requests.

		@see RMobileSmartCardEap::InitialiseEapMethod()
		*/
		EEapMethodInUseApplicationInactive,
		/**
		Lock on the DF_EAP has been released, but another DF_EAP method
		is in use under the same AID, thus, cannot reset/initialise
		this subsessions EAP method.  Client can only post a
		notification and wait till status changes to
		EEapMethodAvailable.

		@see RMobileSmartCardEap::NotifyEapMethodAccessStatusChange()
		*/
		EEapMethodUnableToInitialise
		};

	IMPORT_C TInt ReleaseEapMethod();
	IMPORT_C TInt GetEapMethodAccessStatus(TEapMethodAccessStatus& aEapMethodStatus);
	IMPORT_C void NotifyEapMethodAccessStatusChange(TRequestStatus& aReqStatus, TEapMethodAccessStatus& aEapMethodStatus);
	IMPORT_C TBool IsEapMethodOwner() const;

protected:
	IMPORT_C void ConstructL();
	IMPORT_C void Destruct();

private:
	RMobileSmartCardEap(const RMobileSmartCardEap&);

	TChar SeptChar(TInt aDigit);
	void ConvertBinToText(const TDesC8& aBinData, TDes& aText);

private:
	/**
	Pointer Holder for the RMobileSmartCardEap sub-session requests.
	*/
	CMobileSmartCardEapPtrHolder* iMmPtrHolder;
	/**
	True if this object is the first to request	InitialiseEapMethod()
	on its <AID,EAPType> when the status is EEapMethodAvailable.
	I.e. True only for the instance of RMobileSmartCardEap that
	successfully passes the Wait() on iSemaphore.
	*/
	TBool iOwnsEapMethodLock;
	/**
	Semaphore is actually owned by TSY, and used by all instances of
	RMobileSmartCardEap	to stop multiple access to the same EAP method
	on any one application.
	*/
	RSemaphore iSemaphore;

	};	// RMobileSmartCardEap

/////////////////////////////////////////////////////////////////////////////////////
//
// LCS-MO-LR AND LCS-MT-LR
//
/////////////////////////////////////////////////////////////////////////////////////
class CMobileLocationServicesPtrHolder;

/**
This sub-session opens under RMobilePhone.

A new RMobileLocationServices class is used to add the ETelMM Support for Mobile Terminating Location Request,
Mobile Originating Location Requests, A-Gps assistance data for the LBS Framework.

RMobileLocationServices is derived from RTelSubSessionBase.RMobileLocationServices lists the 
APIs,which provided the support for Mtlr, Molr, A-Gps assistance data requests.
*/
class RMobileLocationServices : public RTelSubSessionBase
	{
public:
	
	IMPORT_C RMobileLocationServices();
    IMPORT_C TInt Open(RMobilePhone& aPhone);
    IMPORT_C void Close();
 	/** 
 	Maximum length of the array used for TLcsRequestorIdString.
 	*/
	enum { KLcsMaxRequestorIdStringSize = 256 };
	/** 
	Maximum length of the array used for TLcsClientBufferName.
 	*/
	enum { KLcsMaxClientNameBufferSize = 256 };
	/** 
	Maximum length of the array used for TLcsClientExternalID.
	*/
	enum { KLcsMaxClientExternalIdSize = 64 };
	/** 
	Maximum length of the array used for TLcsLocationEstimate.
	*/
	enum { KLcsMaxLocationEstimateSize = 64 };
	/** 
	Maximum length of the array used for TLcsVelocityEstimate.
	*/
	enum { KLcsMaxVelocityEstimateSize = 64 };
	/** 
	Maximum length of the array used for TLcsGpsAssistanceData.
	*/
	enum { KLcsMaxGpsAssistanceDataSize = 64 };
	/** 
	A typedef'd buffer which holds the External ClientName Buffer.
	@see KLcsMaxClientNameBufferSize
	*/
	typedef TBuf8<KLcsMaxClientNameBufferSize> TLcsClientNameBuffer;
	/** 
	A typedef'd buffer which holds the RequestorId String.
	@see KLcsMaxRequestorIdStringSize
	*/
	typedef TBuf8<KLcsMaxRequestorIdStringSize> TLcsRequestorIdString;
	/**
	A typedef'd buffer which holds the Gps Assistance Data.
	@see KLcsMaxGpsAssistanceDataSize
	*/
	typedef TBuf8<KLcsMaxGpsAssistanceDataSize> TGpsAssistanceData;
	/**
	A typedef'd buffer which holds the External ClientId.
	@see KLcsMaxClientExternalIdSize
	*/
	typedef TBuf8<KLcsMaxClientExternalIdSize> TLcsClientExternalID;
	/**
	A typedef'd TUint8 which holds the Data Coding Scheme information.
	*/
	typedef TUint8 TLcsDataCodingScheme;
	/**
	A typedef'd buffer which holds the Location Estimate.
	@see KLcsMaxLocationEstimateSize
 	*/
	typedef TBuf8<KLcsMaxLocationEstimateSize> TLcsLocationEstimate;
	/**
	A typedef'd buffer which holds the Velocity Estimate.
	@see KLcsMaxVelocityEstimateSize
	*/
	typedef TBuf8<KLcsMaxVelocityEstimateSize> TLcsVelocityEstimate;
	/**
	A typedef'd buffer which holds the GpsAssistanceData type.
	@see KLcsMaxGpsAssistanceDataSize
	*/
	typedef TBuf8<KLcsMaxGpsAssistanceDataSize> TGpsAssistanceData;
	typedef TUint8 TTransactionIdentifier;
	typedef TUint8 TGPSI;
 	 /**
     Note:Refer to 3GPP TS 23.271(Functional stage 2 description of Location Services (LCS)),
     3GPP TS 24.030(Location Services (LCS); Supplementary service operations - Stage 3) and
     3GPP TS 24.080(Mobile radio interface layer 3 supplementary services specification; Formats and coding)
     for further details of MTLR and MOLR member data.
     */
 /*********************************************************************/ 
 //                  MTLR                                             //
 /*********************************************************************/   
    /**
    TNotificationType lists the various types of Notification
    that can be expected from any MTLR-Location Notification coming from the Network,
    These types depend on the Subscription Profile of the UE. 
    
    One of the TNotificationType is expected to be retrieved from the Network,
    when a UE places a RMobileLocationServices::NotifyMtlr() request on the TSY.
    @internalAll
    */
    enum TNotificationType
		{
		/**
		Notification Type Unknown
		*/
		ENotificationTypeUnknown,
		/**
		The Location Request is accepted by default
		*/
		ENotifyLocationAllowed,
		/**
        This enum is used to indicate to the client, that the user should be notified of the incoming MTLR request, 
        and that the user is expected to respond by granting/denying the request. By defualt, if the user 
        does not provide a response, the request is granted
		*/
		ENotifyAndVerify_LocationAllowedIfNoResponse,
		/**
        This enum is used to indicate to the client, that the user should be notified of the incoming MTLR request, 
        and that the user is expected to respond by granting/denying the request. By defualt, if the 
        user does not provide a response, the request is denied.
		*/
		ENotifyAndVerify_LocationNotAllowedIfNoResponse,
        /**
        The network sends the information to the UE that the external client has privacy overide capability,
        This indicator is received when an authenticated or emergency client had sent the request.
		*/     
        ELocationPrivacyOverride,  
        /**
        This enum is used to notify the UE that an incoming MTLR request was denied by the network for any of various 
        reasons.
		*/
		ELocationNotAllowed                                      
        };

    
    /**
    TLocationEstimateType lists the various types of LocationEstimate
    that can be expected from any MTLR-Location Notification request coming from the Network,
    These types depend on the Subscription Profile of the UE.
    
    One of the TLocationEstimateType is expected to be retrieved from the Network,
    when a UE places a RMobileLocationServices::NotifyMtlr() request on the TSY.
    @internalAll
    */
    enum TLocationEstimateType
		{
		/**
		Location Estimate Type Unknown.
		*/
		ELocationEstimateTypeUnknown,
		/**
		The External Client has requested for the Current Location of
		the UE.
		*/
		ECurrentLocation,
		/**
		The External Client has requested for the Current Location of
		the UE.Incase,if the request is accepted,But still it fails to
		generate the Location report because of Measurement Control Failure.
		The Client receives the Last Known Location.
		*/
		ECurrentOrLastKnownLocation,
		/**
		The External Client has requested for the initial location of the UE. The current 
		location of the UE may or may not be the initial location.
		*/
		EInitialLocation
		};	
    
    /**
    TLcsClientNameV1 holds the details of the name of the External client, 
    who is making the request via Network.
    TLcsClientNameV1 is used by RMobileLocationServices::NotifyMtlr() request.
    @see TLcsDataCodingScheme
    @see TLcsClientNameBuffer
    @internalAll
    */
    class TLcsClientNameV1
    	{
    public:
    	/**
    	TLcsDataCodingScheme holds the Data Coding Scheme information which is used
    	to extract the ExternalClient name.
    	*/
    	TLcsDataCodingScheme iLcsDataCodingScheme;
    	/**
    	TLcsClientNameBuffer holds the Client name 		
    	*/
    	TLcsClientNameBuffer       iLcsClientNameBuffer;	
    	};
    
    /**
    TLcsRequestorIDV1 holds the details of the RequestorId i.e the details of the 
    Network,Which is carrying the request of External Client to UE
    TLcsRequestorIDV1 is used by RMobileLocationServices::NotifyMtlr() request.
    @see TLcsDataCodingScheme
    @see TLcsRequestorIdString 
    @internalAll
    */
    class TLcsRequestorIDV1
    	{
    public:
        /**
    	TLcsDataCodingScheme holds the Data Coding Scheme information which is used
    	to extract the RequestorId String.
    	*/
    	TLcsDataCodingScheme        iLcsDataCodingScheme;
    	/**
    	TLcsRequestorIdString holds the RequestorId String 		
    	*/
    	TLcsRequestorIdString       iLcsRequestorIdString;	
    	};
    
    /**
    TLocationExternalInfoV1 holds the details of the External client and the Requestor
    TLocationExternalInfoV1 is used by RMobileLocationServices::NotifyMtlr() request
    @see TLcsClientExternalID
    @see TLcsClientNameV1
    @see TLcsRequestorIDV1
    @internalAll
    */
    class TLocationExternalInfoV1
		{
	public:
		/**
		TLcsClientExternalID gives the id of the External client.
		*/
		TLcsClientExternalID     iLcsClientID;
		/**
		TLcsClientNameV1 holds the name of the External Client.
		*/
		TLcsClientNameV1           iLcsClientName;
		/**
		TLcsRequestorIDV1 gives the details of requestor id
		*/
		TLcsRequestorIDV1          iLcsRequestorID;
		};
	
	/**
	TNotifyMtlrV7 holds the details of the MTLR request made by the External client.
	TNotifyMtlrV7 is used by RMobileLocationServices::NotifyMtlr() request
	@see TNotificationType
	@see TLocationEstimateType
	@see TLocationExternalInfoV1
	@internalAll
	*/
	class TNotifyMtlrV7: public RMobilePhone::TMultimodeType 
		{
	public:
		IMPORT_C TNotifyMtlrV7();
	public:
		/**
		TNotificationType holds the type of notification request being made
		*/
		TNotificationType          iNotificationType;
		/**
		TLocationEstimateType holds the type of LocationEstimate is requested 
		*/
		TLocationEstimateType      iMtlrLocationEstimateType;
		/**
		TLocationExternalInfoV7  holds the details of the External client. 
		*/
		TLocationExternalInfoV1      iLocationInfo;
        };
	
   	/**
	A typedef'd packaged TNotifyMtlrV7 for passing through a
	generic API method.

	@internalAll
	*/
	typedef TPckg<TNotifyMtlrV7> TNotifyMtlrV7Pckg;
	
 //MTLR-RESPONSE
 	/**
 	TMtlrResponse is used by the OverLoaded RMobileLocationServices::SendMtlrResponse() API
 	It holds the type of response being sent back for the MTLR request made.
 	@internalAll
 	*/
	
	enum TMtlrResponse
		{
		/**
		Mtlr Response Unknown.
		*/
		EMtlrResponseUnknown,
		/**
		The UE has denied the Location Request  of the External client.
		@see RMobileLocationServices::SendMtlrResponse()
		*/
		EPermissionDenied ,
		/**
		The UE has granted  the Location Request  of the External client.
		@see RMobileLocationServices::SendMtlrResponse()
		*/
		EPermissionGranted
		};
	
	/**
 	TMtlrError is used by the Overloaded RMobileLocationServices::SendMtlrResponse() API
 	It holds the type of Error response being sent back for the MTLR request made.
 	@internalAll
 	*/
 	enum TMtlrError
		{
		/**
		Mtlr Error Unknown.
		*/
		EMtlrErrorUnknown,
		/**
		This response is sent back to the network when System has failed to 
		do the privacy check due to some Miscellaneous reasons
		*/
		ESystemFailure ,
		/**
		The response is sent when the privacy verification has failed because of Unexpected data 
		values retrieved from the Location Notification request generated by the Network.
		This generates an Error-Prone response from UE
		*/
		EUnexpectedDataValue	
		};
	
	/**
 	TMtlrReject is used by the Overloaded RMobileLocationServices::SendMtlrResponse() API
 	It holds the details of the Response being rejected due to one of the problems reported to the UE
 	for the MTLR request being made.
 	@internalAll
 	*/
 	enum TMtlrReject
		{
		/**
		Mtlr Reject Unknown.
		*/
		EMtlrRejectUnknown,
		/**
		This indication is given under a scenario where the UE wants to reject a request,
		It is done by invoking Duplicate ID's.
		*/
		EDuplicateInvokeID,
		/**
		This indication is given under a scenario where the UE wants to reject a request, 
		It is done by saying the operation is not recognized
		*/
		EUnrecognizedOperation,
		/**
		This invokes a problem indicating Resource Limitation.
		*/
		EResourceLimitation,
		/**
		This Invokes a problem initiating release.
		*/
		EInitiatingRelease,
		/**
		This invokes a problem indicating that  the ID linked with the Client information 
		is unrecognized
		*/
		EUnrecognizedLinkedID,
		/**
		This invokes a problem of Linked Response Unexpected
		*/
		ELinkedResponseUnexpected,
		/**
		This invokes a problem of Unexpected Linked Operation
		*/
		EUnexpectedLinkedOperation,
		/**
		This invokes a problem of Mistyped Parameter.
		*/
		EMistypedParameter	
		};
	
   /**************************************************************/
   //                  MOLR                                      //
   /**************************************************************/
 
 	/**
 	TMolrType is used by the SendMolr() API.
 	This gives an indication of type of Molr request the UE wants to invoke
 	@internalAll
 	*/
 	enum TMolrType
		{
		/**
		MolrType UnKnown
		*/
		EMolrTypeUnknown,
		/**
		UE is requesting the Network for its Location Estimate  
		*/
		ELocationEstimate,
		/**
		UE is requesting the Network for  GPS Assistance data
		*/
		EAssistanceData,
		/**
		UE is requesting the Network for  DecipheringKeys
		*/
		EDecipheringKeys
		};

 	/**
 	TResponseTime is used by SendMolr() API
 	This enum holds the various types of delay that an UE is expecting.
 	@internalAll
 	*/
 	enum TResponseTime
  		{
  		/**
  		Response Time Unknown.
		*/
  		EResponseTimeunknown,
  		/**
  		This enum value indicates that the UE expects a Less Time Delay
  		from Network in responding to its request
  		*/
  		ELowDelay,
  		/**
  		This enum value indicates that the UE expects a Long Time Delay
  		from Network in responding to its request and is tolerant to it.
  		*/
  		EDelayTolerant		
  		};
 	
 	/**
 	TLocationMethod is used by SendMolr() API
 	This is an enum which lists out all different types of Location methods that an UE can request
 	@internalAll
 	*/
 	enum TLocationMethod
  		{
  		/**
  		Location Method Unknown
		*/
  		ELocationMethodunknown,
  		/**
  		This indication is given under a scenario where the UE wants a MS (Mobile Station) Based Location Fix.
  		This can be termed as UE Assisted Location Fix(EOTD-Enhanced observed time difference).
  		*/
  		EMSBasedEOTD,
  		/**
  		This indication is given under a scenario where the UE wants a MS (Mobile Station) Assisted Location Fix.
  		This can be termed out as UE based location fix.
  		*/
  		EMSAssistedEOTD,
  		/**
  		This indication is given under a scenario where the UE wants a MS (Mobile Station) Assisted GPS data.
  		*/
  		EMSAssistedGPS,
  		/**
  		This indication is given under a scenario where the UE wants a MS (Mobile Station) based location fix 
  		(OTDOA-Observed time difference of arrival).
  		*/
  		EMSBasedOTDOA
  		}; 
   
    /**
    TQosV1 is used by SendMolr() API
    This is a class with details of accuracy of Position information, Response Time, 
    expected to be received from the network.
    @see TResponseTime
    @internalAll
    */
 	class TQosV1
   		{
   	public:
    	/**
    	This gives an information of the amount of Horizontal accuracy that the UE is expecting.
    	*/
    	TUint8 iHorizontalAccuracy;
    	/**
    	This gives an information of the amount of Vertical accuracy that the UE is expecting. 
    	*/
    	TUint8 iVerticalAccuracy;
    	/**
    	This enum indicates the Response Time expected by the UE to receive a response for its MOlr request.
    	*/
    	TResponseTime iResponseTime;
    	};
    
    /**
    TMolrErrors is used by SendMolr() API
    This is an enum which lists out all the possible errors that can be 
    reported to UE by an External Client or the Network.
    @internalAll
    */
   	enum TMolrErrors
    	{
    	/**
    	Molr Error Unknown
		*/
    	EMolrErrorUnknown,
    	/**
    	This indication is given to the UE when the Location Report is unable to reach the 
    	External Client due to some failure in the Network Connections.
    	*/
        EMolrSystemFailure, 
        /**
        This indication is given back to the UE by the Network to the UE or by the 
        External Client to the UE,where the UE generated MOLR has some unexpected values. 
        */
        EMolrUnexpectedDataValue,  
        /**
        This indication is given back to the UE by the Network to the UE or by the 
        External Client to the UE,where the UE generated MOLR had a data discrepancy
        */
        EMolrDataMissing, 
        /**
        This indication is given by the Network to the UE, 
        when the UE is not given a facility to make a MOLR request
        */
        EMolrFacilityNotSupported, 
        /**
        This indication is given by the Network to the UE, 
        when the subscription profile of the UE doesn't match with the requests made by it.
        */
        EMolrSS_SubscriptionViolation, 
        /**
        This indication is given by the Network to the UE, 
        when the UE or the Network failed to generate the Location estimate
        */ 
        EMolrPositionMethodFailure 
        };

	/**
	TStartMolrV7 is used by SendMolr() API
	This class lists the details send by UE to Network when a Molr request is being made.
	@see TMolrType
	@see TQosV1
	@see TLocationEstimateType
	@see TLcsClientExternalID
	@see TGpsAssistanceData
	@see TLocationMethod
	@internalAll
	*/
	class TStartMolrV7: public RMobilePhone::TMultimodeType
		{
	public:
		IMPORT_C TStartMolrV7();
	public:
		/**
		TMolrType holds the type of Molr request being made
		*/
		TMolrType             iMolrType;
		/**
		TQosV1 lists out the Quality of Service expected by UE
		*/
		TQosV1                iQos;
		/**
		Type of Location Estimate requested
		*/
		TLocationEstimateType iMolrLocationEstimateType;
		/**
		Id of the External client
		*/
		TLcsClientExternalID  iLcsClientExternalID;
		/**
		Type of GpsAssistanceData
		*/
		TGpsAssistanceData    iGpsAssistanceData;
		/**
		Type of Location method requested
		*/
		TLocationMethod       iLocationMethod ;
		/**
		Type of Service requested
		*/
		TUint8                 iLcsServiceTypeID;
		};
	/**
	A typedef'd packaged TStartMolrV7 for passing through a
	generic API method.

	@internalAll
	*/
	typedef TPckg<TStartMolrV7> TStartMolrV7Pckg;
	
	/**
	TMolrReturnResultV7 is used by SendMolr() API
	This class lists all the Molr return results that can be expected for the Molr request
	being made.
	@see TLcsLocationEstimate 
	@see TLcsVelocityEstimate
	@see TMolrErrors
	@internalAll
	*/
    class TMolrReturnResultV7: public RMobilePhone::TMultimodeType
    	{
    public:
		IMPORT_C TMolrReturnResultV7();
    public:
    	/**
    	This gives the Location Estimate of the UE
    	*/
    	TLcsLocationEstimate    iLocationEstimate;
    	/**
    	This gives the Velocity Estimate of the UE
    	*/
    	TLcsVelocityEstimate	iVelocityEstimate;
    	/**
    	This gives the indication of the type of error occured
    	*/
    	TMolrErrors             iMolrErrors;
    	};

	/**
	A typedef'd packaged TMolrReturnResultV7 for passing through a
	generic API method.

	@internalAll
	*/
	typedef TPckg<TMolrReturnResultV7> TMolrReturnResultV7Pckg;
	
	//**************************************//
	// Measurement Control Data structures	//
	//**************************************//

	enum 
		{
		/**Maximum number of monitored cells RACH*/
		KMaxMonitoredCells = 8,
		/**Maximum number of satellites*/
		KMaxSat = 16,
		/**GlobalHealth size. 364 bits =46 bytes (Rounded) */
		KGlobalHealthSize	= 46
		};

	/**This enum contains the possible types of measurement commands.*/
	enum TMeasurementCmd
		{
		/**Measurement Command Unknown*/
		EMeasCommandUnknown,
		/**Setup a new measurement*/
		ESetup,
		/**Modify a previously defined measurement, e.g. to change the reporting criteria*/
		EModify,
		/**Indicates to stop a measurement and clear all information in the UE that are related to that measurement */
		ERelease,
		};

	/**This enum contains the possible positioning method types*/
	enum TUePosMethodType
		{
		/**Positioning Method Type unknown*/
		EPosMethodTypeUnknown,
		/**UE Assisted : The network computes the location of the UE.*/
		EUeAssisted,
		/**UE Based : The UE computes the location of itself*/
		EUeBased,
		};

	/**This enum contains the possible positioning methods*/
	enum TPosMethod
		{
		/**Positioning Method unknown*/
		EPosMethodUnknown,
		/**OTDOA may be selected by the SRNC as the method to be used on receipt of an LCS positioning request from the CN */
		EOtdoa,
		/**These methods make use of UEs, which are equipped with radio receivers capable of receiving GPS signals*/
		EGps,
		/**Use either OTDOA or GPS positioning method.*/
		EOtdoaOrGps,
		/**
		In the cell ID based (i.e. cell coverage) method, the position of an UE is 
		estimated with the knowledge of its serving Node B. The information about the serving 
		Node B and cell may be obtained by paging,locating area update, cell update, URA update, or routing area update.
		*/
		ECellID
		};

	/**
	This class contains the information which is part of the Navigation Model.
	This can be requested by the UE as part of additional request.
	*/
	class TSatDataV1
		{
	public:
		/**Satellite identity*/
		TUint8		iSatID;
		/**Issue of Data Ephemeris for SatID*/
		TUint8		iIode;
		};
	
	/**
	This class contains the additional information that can be requested by the UE.
	*/
	class TNavModelAddlDataReqV1	
		{
	public:
		/**GPS time in weeks*/
		TUint16		iGpsWeek;
		/**GPS time of ephemeris in hours of the latest ephemeris set contained by the UE.*/
		TUint8		iGpsToe;
		/**Ephemeris age tolerance of the UE to UTRAN in hours.*/
		TUint8		iTToeLimit;
		/**Satellite Identities
		@see TSatDataV1*/
		TSatDataV1	iSatData[KMaxSat];
		};

	/**This class contains the indicators to request for additional assistance data from the network.*/
	class TGpsAddlAssistDataReqV1
		{
	public:
		/**ETrue indicates Almanac Data is requested
		@see	TAlmanacV1*/
		TBool	iAlmanacRequest;
		/**ETrue indicates UTC model Data is requested
		@see	TUtcModelV1*/
		TBool	iUtcModelRequest;
		/**ETrue indicates Ionospheric Model Data is requested
		@see	TUtcModelV1*/
		TBool	iIonosphericModelRequest;
		/**ETrue indicates Navigation model Data is requested
		@see	TIonosphericModelV1*/
		TBool	iNavigationModelRequest;
		/**ETrue indicates DGPS corrections Data is requested
		@see	TNavigationModelSatInfoV1*/
		TBool	iDgpsCorrectionsRequest;
		/**ETrue indicates Reference location Data is requested
		@see	TDgpsCorrectionsV1*/
		TBool	iReferenceLocationRequest;
		/**ETrue indicates Reference time Data is requested
		@see	TReferenceLocationV1*/
		TBool	iReferenceTimeRequest;
		/**ETrue indicates Acquisition assistance Data is requested
		@see	TReferenceTimeV1*/
		TBool	iAcquisitionAssistanceReq;
		/**ETrue indicates Realtime integrity Data is requested
		@see	TAcquisitionAssistanceV1*/
		TBool	iRealTimeIntegrityRequest;
		/**This member is included only if Navigagion Model Data is requested (iNavigationModelRequest is ETrue).
		@see	TNavModelAddlDataReqV1*/
		TNavModelAddlDataReqV1	iNavModelAddlDataReq;
		};

	/**This class contains the UE positioning reporting quantity*/
	class TUePosReportingQuantityV1
		{
	public:
		/**Holds the positioning method type*/
		TUePosMethodType	 iUePosMethodType;
		/**Holds the positioning method*/
		TPosMethod 	iPosMethod;
		/**Holds the horizontal accuracy*/
		TInt8	iHorzAccuracy;
		/**Holds the vertical accuracy*/
		TInt8	iVertAccuracy;
		/**If true the SRNC wants the UE to report the SFN-GPS timing of the reference cell.*/ 
		TBool 	iGpsTimingOfCellWanted;
		/**ETrue indicates that the UE is requested to send the IE "Additional assistance Data Request" 
		when the IE "UE positioning Error" is present in the UE positioning measured results.
		EFalse indicates that the UE shall use the assistance data available.
		*/
		TBool	iAddlAssistanceDataReq;
		};

	/**This enum contains the states in which measurements are valid*/
	enum TMeasurementValidity
		{
		/**Measurement Validity Unknown*/
		EMeasValidityUnknown,
		/**Indicates measurement is valid in CellDCH state*/
		ECellDCH,
		/**Indicates measurement is valid except in CellDCH state*/
		EAllButCellDCH,
		/**Indicates measurement is valid in all state*/
		EAllStates
		};

	/**This enum list the SfnTow uncertainity*/
	enum TSfnTowUncertainity
		{
		/**Sfn Tow Uncertainity unknown*/
		ESfnTowUncertainityUnknown,
		/**SfnTowUncertainity < 10*/
		ELessThan10,
		/**SfnTowUncertainity > 10*/
		EMoreThan10
		};
	
	/**This enum lists the different GPS drift rates*/
	enum TUtranGpsDriftRate
		{
		/**GPS Drift rate unknown*/
		EDriftRateUnknown,
		/**Drift = 0*/
		EUtranGpsDrift0,
		/**Drift = 1*/
		EUtranGpsDrift1,
		/**Drift = 2*/
		EUtranGpsDrift2,
		/**Drift = 5*/
		EUtranGpsDrift5,
		/**Drift = 10*/
		EUtranGpsDrift10,
		/**Drift = 15*/
		EUtranGpsDrift15,
		/**Drift = 25*/
		EUtranGpsDrift25,
		/**Drift = 50*/
		EUtranGpsDrift50,
		/**Drift = -1*/
		EUtranGpsDriftMinus1,
		/**Drift = -2*/
		EUtranGpsDriftMinus2,
		/**Drift = -5*/
		EUtranGpsDriftMinus5,
		/**Drift = -10*/
		EUtranGpsDriftMinus10,
		/**Drift = -15*/
		EUtranGpsDriftMinus15,
		/**Drift = -25*/
		EUtranGpsDriftMinus25,
		/**Drift = -50*/
		EUtranGpsDriftMinus50,
		};

	/**This enum lists the different Udre values*/
	enum TDiffCorrectionsStatus
		{
		/**Diff Corrections Status unknown*/
		ECorrectionStatusUnknown,
		/**UDRE 1.0 */
		EUdre1Point0,
		/**UDRE 0.75 */
		EUdre0Point75,
		/**UDRE 0.5 */
		EUdre0Point5,
		/**UDRE 0.3 */
		EUdre0Point3,
		/**UDRE 0.2 */
		EUdre0Point2,
		/**UDRE 0.1 */
		EUdre0Point1,
		/**UDRE No Data */
		ENoData,
		/**UDRE Invalid Data */
		EInvalidData
		};
	
	/**This class reserves members for future use*/
	class TSubFrame1ReservedV1
		{
	public:
		/**Reserve member 1*/
		TUint	iReserved1;
		/**Reserve member 2*/
		TUint	iReserved2;
		/**Reserve member 3*/
		TUint	iReserved3;
		/**Reserve member 4*/
		TUint	iReserved4;
		};

	/**This class contains information for GPS ephemeris and clock correction.*/
	class TEphemerisParameterV1
		{
	public:
		/**Code(s) on L2 Channel */
		TUint8	iCodeOnL2;
		/**User Range Accuracy */
		TUint8	iUraIndex;
		/**Health of Satellite*/
		TUint8	iSatHealth;
		/**Issue of Data, Clock */
		TUint16	iIodc;
		/**L2 channel flag*/
		TUint8	iL2Flag;
		TSubFrame1ReservedV1	iSubFrame1Reserved;
		/**Estimated group delay differential */
		TUint8	iTGd;
		/**Apparent clock correction*/
		TUint16	iTOc;
		/**Apparent clock correction*/
		TUint8	iAf2;
		/**Apparent clock correction*/
		TUint16	iAf1;
		/**Apparent clock correction*/
		TUint	iAf0;
		/**Amplitude of the Sine Harmonic Correction Term to the Orbit Radius (meters)*/
		TUint16	iCRs;
		/**Mean Motion Difference From Computed Value (semi-circles/sec)*/
		TUint16	iDeltaN;
		/**Mean Anomaly at Reference Time (semi-circles)*/
		TUint	iM0;
		/**Amplitude of the Cosine Harmonic Correction Term To The Argument Of Latitude (radians)*/
		TUint16	iCUc;
		/**Eccentricity*/
		TUint	iE;
		/**Amplitude of the Sine Harmonic Correction Term To The Argument Of Latitude (radians)*/
		TUint16	iCUs;
		/**Semi-Major Axis in squareroot(meters) */
		TUint	iASqrt;
		/**Reference Time Ephemeris */
		TUint16	iTOe;
		/**
		Fit interval flag
		@see ICD-GPS-200
		*/
		TUint8	iFitInterval;
		/**Age Of Data Offset */
		TUint8	iAodo;
		/**Amplitude of the Cosine Harmonic Correction Term To The Angle Of Inclination (radians)*/
		TUint16	iCIc;
		/**Longitude of Ascending Node of Orbit Plane at Weekly Epoch (semi-circles) */
		TUint	iOmega0;
		/**Amplitude of the Sine Harmonic Correction Term To The Angle Of Inclination (radians) */
		TUint16	iCIs;
		/**Inclination Angle at Reference Time (semi-circles) */
		TUint	i0;
		/**Amplitude of the Cosine Harmonic Correction Term to the Orbit Radius (meters) */
		TUint16	iCRc;
		/**Argument of Perigee (semi-circles) */
		TUint	iOmega;
		/**Longitude of Ascending Node of Orbit Plane at Weekly Epoch (semi-circles/sec) */
		TUint	iOmegaDot;
		/**Rate of Inclination Angle (semi-circles/sec) */
		TUint16	iDot;
		};

	/**This enum specifies the possible status of a satellite*/
	enum TSatelliteStatus
		{
		/**Satellite Status unknown*/
		ESatStatusUnknown,
		/**New satellite, new Navigation Model*/
		ENsNnU,
		/**Existing satellite, same Navigation Model*/
		EEsSn,
		/**Existing satellite, new Navigation Model*/
		EEsNnU,
		/**Reserved*/
		ERev2,
		/**Reserved*/
		ERev
		};

	/**This class contains the navigation model satellite information*/
	class TNavigationModelSatInfoV1
		{
	public:
		/**Satellite identification*/
		TUint8				iSatID;
		/**Status of the satellite*/
		TSatelliteStatus	iSatelliteStatus;
		/**Contains information for GPS ephemeris and clock correction.*/
		TEphemerisParameterV1	iEphemerisParameter;
		};

	/**
	This class contains the ionospheric model information needed to model
	the propagation delays of the GPS signals through the ionosphere
	*/
	class TIonosphericModelV1
		{
	public:
		/**
		The parameters *n are the coefficients of a cubic equation 
		representing the amplitude of the vertical delay.
		@see ICD-GPS-200
		*/
		/**Alfa = 0*/
		TUint8	iAlfa0;
		/**Alfa = 1*/
		TUint8	iAlfa1;
		/**Alfa = 2*/
		TUint8	iAlfa2;
		/**Alfa = 3*/
		TUint8	iAlfa3;
		/**
		The parameters *n are the coefficients of a cubic equation 
		representing the period of the ionospheric model 
		@see ICD-GPS-200
		*/
		/**Beta = 0*/
		TUint8	iBeta0;
		/**Beta = 1*/
		TUint8	iBeta1;
		/**Beta = 2*/
		TUint8	iBeta2;
		/**Beta = 3*/
		TUint8	iBeta3;
		};
		
	/**
	This class contains the UTC model information needed to relate GPS time to Universal Time Coordinate (UTC)
	@see ICD-GPS-200
	*/
	class TUtcModelV1
		{
	public:
		/**
		Time in seconds. 
		@see ICD-GPS-200.
		*/
		TUint	iA1;
		/**
		Time in seconds. 
		@see ICD-GPS-200.
		*/
		TUint	iA2;
		/**Time in seconds
		@see ICD-GPS-200
		*/
		TUint8	iTOt;
		/**weeks
		@see ICD-GPS-200
		*/
		TUint8	iWnT;
		/**Time in seconds
		@see ICD-GPS-200
		*/
		TUint8	iDeltaTLs;
		/**Weeks
		@see ICD-GPS-200
		*/
		TUint8	iWnLsf;
		/**Days
		@see ICD-GPS-200
		*/
		TUint8	iDn;
		/**Seconds
		@see ICD-GPS-200
		*/
		TUint8	iDeltaTLsf;
		};

	/**This class contains a reduced-precision subset of the ephemeris and clock correction parameters.*/
	class TAlmanacSatInfoV1
		{
	public:
		/**Data identification*/
		TUint8	iDataID;
		/**Eccentricity*/
		TUint16	iE;
		/**Reference Time of Almanac */
		TUint8 	iTOa;
		/**@see ICD-GPS-200*/
		TUint16	iDeltaI;
		/**Longitude of Ascending Node of Orbit Plane at Weekly Epoch (semi-circles/sec) */
		TUint16	iOmegaDot;
		/**Satellite health*/
		TUint8	iSatHealth;
		/**Semi-Major Axis in squareroot(meters)*/
		TUint	iASqrt;
		/**Longitude of Ascending Node of Orbit Plane at Weekly Epoch (semi-circles) */
		TUint	iOmega0;
		/**Mean Anomaly at Reference Time (semi-circles) */
		TUint	iM0;
		/**Argument of Perigee (semi-circles) */
		TUint	iOmega;
		/**Apparent clock correction */
		TUint16	iAf0;
		/**Apparent clock correction */
		TUint16	iAf1;
		};

	/**This class holds the coarse, long-term model of the satellite positions and clocks.*/
	class TAlmanacV1
		{
	public:
		/**Almanac Reference Week */
		TUint8	iWnA;
		TAlmanacSatInfoV1	iAlmanacSatInfoList[KMaxSat]; 
		/**This enables GPS time recovery and possibly extended GPS correlation intervals.*/
		TUint16	iSvGlobalHealth[KGlobalHealthSize]; 
		};

	/**This union contains the information specific to mode - FDD/TDD*/
	union TModeSpecificInfoV1
		{
		/**Used in FDD mode*/
		TUint16	iPrimaryScramblingCode;
		/**Used in TDD mode*/
		TUint16	iCellParametersID;
		};

	/**This class contains parameters that enable fast acquisition of the GPS 
	   signals in UE-assisted GPS positioning.*/
	class TAcquisitionAssistanceV1
		{
	public:
		/**Specifies GPS reference time*/
		TUint				iGpsReferenceTime;
		/**Specifies GPS reference time specific to mode - FDD/TDD*/
		TModeSpecificInfoV1	iUtranGpsReferenceTime;
		/**ETrue indicates iUtranGpsReferenceTime is iPrimaryScramblingCode. 
		EFalse indicates iUtranGpsReferenceTime is iCellParametersID*/
		TBool	iUtranGpsRefTimeStatus;
		};

	/**
	The UDRE provides an estimate of the uncertainty (1-*) in the corrections for 
	the particular satellite. The value in this field shall be multiplied by the 
	UDRE Scale Factor in the common Corrections Status/Health field to determine the 
	final UDRE estimate for the particular satellite. 
	@see 3GPP TS 25.305
	*/
	enum TUdre
		{
		/**Udre unknown*/
		EUdreUnknown,
		/** UDRE < 1*/
		ELessThan1,
		/** 1> UDRE < 4*/
		EBtw1And4,
		/** 1> UDRE < 8*/
		EBtw1And8,
		/** UDRE > 8*/
		EOver8
		};

	/**This class contains DGPS corrections to be used by the UE*/
	class TDgpsCorrectionSatInfoV1
		{
	public:
		/**Satellite identification*/
		TUint8	iSatID;
		/**Issue of Data Ephemeris for SatID.*/
		TUint8	iIode;
		/**
		The UDRE provides an estimate of the uncertainty (1-*) in the corrections for 
		the particular satellite. The value in this field shall be multiplied by the 
		UDRE Scale Factor in the common Corrections Status/Health field to determine the 
		final UDRE estimate for the particular satellite. 
		@see 3GPP TS 25.305
		*/
		TUdre	iUdre;
		/**The PRC indicates the correction to the pseudorange for the particular satellite at the GPS Reference Time*/
		TInt16	iPrc;
		/**
		This information indicates the rate-of-change of the pseudorange correction for the particular satellite,
		using the satellite ephemeris identified by the IODE IE
		*/
		TInt8	iRrc;
		/**For future use*/
		TInt8	iDummy1;
		/**For future use*/
		TInt8	iDummy2;
		};

	/**This class contains the DGPS corrections information*/
	class TDgpsCorrectionsV1
		{
	public:
		/**GPS time of week*/
		TUint16				iGpsTow;
		/**This information indicates the status of the differential corrections contained in the message.*/
		TDiffCorrectionsStatus	iStatusHealth;
		/**This member data contains DGPS corrections of the satellites to be used by the UE*/
		TDgpsCorrectionSatInfoV1	iDgpsCorrectionSatInfoList[KMaxSat];
		};

	/**This enum containst the possible signs of latitude*/
	enum TLatitudeSign
		{
		/**Latitude Sign Unknown*/
		ELatitudeSignUnknown,
		/**Latitude sign is north*/
		ENorth,
		/**Latitude sign is south*/
		ESouth
		};
	
	/**This enum contains the possible directions of altitudes for reference location*/
	enum TAltDirection
		{
		/**Altitude Direction Unknown*/
		EAltDirectionUnknown,
		/**Indicates Altitude direction is height-wise*/
		EHeight,
		/**Indicates Altitude direction is depth-wise*/
		EDepth
		};

	/**This class contains a 3-D location (with uncertainty)*/
	class TReferenceLocationV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**Degree of latitude*/
		TUint16			iLatitude;
		/**Degree of longitude*/
		TInt16			iLongitude;
		/**Direction of altitude*/
		TAltDirection	iAltDirection;
		/**Degree of altitude*/
		TUint16			iAltitude;
		/**Uncertainty semi major axis*/
		TUint8			iUncertainitySemiMajor;
		/**Uncertainty semi minor axis*/
		TUint8			iUncertainitySemiMinor;
		/**Orientation of major axis*/
		TUint8			iOrientationMajorAxis;
		/**The uncertainty in altitude, h, expressed in metres*/
		TUint8			iUncertainityAltitude;
		/**The confidence by which the position of a target entity is known to be within the shape description*/
		TUint8			iConfidence;
		};

	/**
	Contains several fields in the Telemetry (TLM) Word and Handover Word (HOW) 
	that are currently being broadcast by the respective GPS satellites. Combining this information 
	with GPS TOW helps the UE with time-recovery needed to predict satellite signal.
	*/
	class TGpsTowAssistV1
		{
	public:
		/**Satellite identification*/
		TUint8				iSatID;
		/**
		Contains a 14-bit value representing the Telemetry Message (TLM) 
		being broadcast by the GPS satellite identified by the particular SatID, 
		with the MSB occurring first in the satellite transmission.
		*/
		TUint16				iTlmMsg;
		/**
		Contains the two reserved bits in the TLM Word 
		being broadcast by the GPS satellite identified by SatID, 
		with the MSB occurring first in the satellite transmission.
		*/
		TUint8				iTlmReserved;
		/**Contain the Alert flags that are being broadcast by the GPS satellite identified by SatID.*/
		TBool				iAlert;
		/**Contain the Anti-Spoof that are being broadcast by the GPS satellite identified by SatID.*/
		TBool				iAntiSpoof;
		};

	/**This class contains information that may be used to provide a mapping between UTRAN and GPS time*/
	class TUtranGpsRefTimeV1
		{
	public:
		/**UE-GPS timing of cell ms-part*/
		TUint16 			iMsPart;
		/**UE-GPS timing of cell ls-part*/
		TUint16				iLsPart;
		/**System frame number*/
		TUint16				iSfn;
		/**Specifies GPS reference time specific to mode - FDD/TDD*/
		TModeSpecificInfoV1	iModeSpecificInfo;
		/**ETrue indicates iUtranGpsReferenceTime is iPrimaryScramblingCode. 
		EFalse indicates iUtranGpsReferenceTime is iCellParametersID*/
		TBool	iModeSpecificInfoStatus;
		};

	/**
	This class contains several fields in the Telemetry (TLM) Word and Handover Word (HOW) 
	that are currently being broadcast by the respective GPS satellites. Combining this information 
	with GPS TOW helps the UE with time-recovery needed to predict satellite signal.
	*/
	class TReferenceTimeV1
		{
	public:
		/**GPS time in weeks*/
		TUint16				iGpsWeek;
		/**GPS Time of Week in milliseconds */
		TUint16				iGpsTowOneMsec;
		/**GPS reference time may be used to provide a mapping between UTRAN and GPS time*/
		TUtranGpsRefTimeV1	iUtranGpsRefTime;
		/**
		This field indicates the uncertainty of the relation GPS TOW/SFN. 
		ELessThan10 means the relation is accurate to at least 10 ms.
		*/
		TSfnTowUncertainity	iSfnTowUncertainity;
		/**Drift rate of the NODE B clock relative to GPS time.*/
		TUtranGpsDriftRate	iUtranGpsDriftRate;
		/**
		Contains several fields in the Telemetry (TLM) Word and Handover Word (HOW) 
		that are currently being broadcast by the respective GPS satellites. Combining this information 
		with GPS TOW helps the UE with time-recovery needed to predict satellite signal.
		*/
		TGpsTowAssistV1		iGpsTowAssistList[KMaxSat];
		};

	/**This class contains the GPS Assistance Data received from network*/
	class TUePosGpsAssistanceDataV1
		{
	public:
		/**GPS reference time may be used to provide a mapping between UTRAN and GPS time.*/
		TReferenceTimeV1 			iReferencTime;
		/**The Reference Location contains a 3-D location (with uncertainty)*/
		TReferenceLocationV1		iReferenceLocation;
		/**
		Holds information to allow a UE to estimate its position more accurate,
		biases in the pseudorange measurements may be provided to the UE.
		*/
		TDgpsCorrectionsV1			iDgpsCorrections;
		/**Holds navigation model satellite information*/
		TNavigationModelSatInfoV1	iNavigationModel;
		/**
		The Ionospheric Model contains information needed to model
		the propagation delays of the GPS signals through the ionosphere.
		*/
		TIonosphericModelV1			iIonosphericModel;
		/**UTC parameters may be used to provide Coordinated Universal Time to the UE.*/
		TUtcModelV1					iUtcModel;
		/**Holds the coarse, long-term model of the satellite positions and clocks.*/
		TAlmanacV1					iAlmanac;
		/**Holds the acquistions assistance information of the UE*/
		TAcquisitionAssistanceV1	iAcquisitionAssistance;
		/**Holds the list of bad satellites*/
		TUint8						iBadSatList[KMaxSat];
		/**
		This member specifies which of the above additional data structures are populated.
		*/
		TGpsAddlAssistDataReqV1 iGpsAddlDataStatus;
		};

	/**This class contains the GPS assistance data required to compute the UE Postioning information*/
	class TUePosMeasurementV1
		{
	public:
		/**
		The purpose of the element is to express the allowed/required location method(s), 
		and to provide information desired QoS.
		*/
		TUePosReportingQuantityV1	iUePosReportingQuantity;
		/**This member data defines in which UE states the measurement is valid.*/
		TMeasurementValidity		iMeasurementValidity;
		/**This member data holds the GPS Assistance Data sent by the network*/
		TUePosGpsAssistanceDataV1	iUePosGpsAssistanceData;
		};

	/**This holds the possible types of measurement commands that can be specified*/
	union TMeasurementCommandV1
		{
		/**Setup a new measurement*/
		TUePosMeasurementV1	iSetup;
		/**Modify a previously defined measurement*/
		TUePosMeasurementV1	iModify;
		/**Stop the measurement and clear all information in the UE that are related to that measurement.*/
		TBool	iRelease;
		};

	/**This enum specifies the mode the UE shall use to transmit the measurement report*/
	enum TMeasReportTransferMode
		{
		/**Transfer mode unknown*/
		ETransferModeUnknown,
		/**The UE shall transmit the measurement report using Acknowledged RLC mode*/
		EAckModeRlc,
		/**The UE shall transmit the measurement report using Unacknowledged RLC mode*/
		EUnAckModeRlc
		};

	/**
	This class contains the GPS assistance data needed by the UE to compute the location 
	of the UE. The UE computes the location once it receives all required information.
	*/
	class TMeasurementControlV7 : public RMobilePhone::TMultimodeType
		{
	public:
		IMPORT_C TMeasurementControlV7();
	public:
		/**
		A reference number that should be used by the UTRAN when setting up, 
		modifying or releasing the measurement and by the UE in the measurement report.
		*/
		TUint8	iMeasurementIdentity;
		/**Specifies the Measurement Setup / Modify / Release*/
		TMeasurementCommandV1	iMeasurementCommand;
		/**This specifies whether the UE shall transmit the measurement report using AM or UM RLC.*/
		TMeasReportTransferMode iMeasReportTransferMode;
		/**ETrue indicates velocity estimate is requested. EFalse indicates velocity estimate is not requested*/
		TBool	iVelocityRequested;
		/**Holds the type of measurement command being used*/
		TMeasurementCmd	iMeasurementCmdStatus;
		};
   	/**
	A typedef'd packaged TMeasurementControlV7 for passing through a
	generic API method.

	@internalAll
	*/
	typedef TPckg<TMeasurementControlV7> TMeasurementControlV7Pckg;
	
	//**************************************//
	// Measurement Report Data structures	//
	//**************************************//

	
	/**
	This enum contains the indicators thta specify which 
	union members of TMeasurementQuantityV1 are included
	*/
	enum TMeasQnty
		{
		/**Measurement Quantity unknown*/
		EMeasQntyUnknown,
		/**Indicates that CpichEcN0 is present*/
		EMeasQntyCpichEcN0Present,
		/**Indicates that CpichRscp is present*/
		EMeasQntyCpichRscpPresent,
		/**Indicates that path loss is present*/
		EMeasQntyPathLossPresent,
		};

	/**
	This enum contains the indicators that specify which 
	union members of TPosEstimateRefTime and  TPositionEstimateV1 are included
	*/
	enum TPosEstimateInfo
		{
		/**Position Estimate Info Unknown*/
		EPosEstimateInfoUnknown,
		/**
		NOTE: The following states correspond to TUePosPositionEstimateInfoV1/TPosEstimateRefTime
		Indicates that UE positioning estimate reference time is populated
		*/
		EUtranGpsRefTimeResultPresent,
		/**Indicates that GPS reference time is populated*/
		EGpsRefTimeOnlyPresent,
		/**Indicates that cell timing is populated*/
		ECellTimingPresent,
		/**
		NOTE: The following states correspond to TUePosPositionEstimateInfoV1/TPositionEstimateV1.
		Indicates EllipsoidPoint is populated
		*/
		EEllipsoidPointPresent,
		/**Indicates EllipsoidPoint with uncertainty circle is populated*/
		EEllipsoidPointUncertCirclePresent,
		/**Indicates EllipsoidPoint with uncertainty ellipse is populated*/
		EEllipsoidPointUncertEllipsePresent,
		/**Indicates EllipsoidPoint with altitude is populated*/
		EEllipsoidPointAltitudePresent,
		/**Indicates EllipsoidPoint with altitude and ellipse is populated*/
		EEllipsoidPointAltEllipsePresent,
		};

	/**This enum contains the possible types of velocity estimates*/
	enum TVelEstimate
		{
		/**Velocity Estimate Unknown*/
		EVelEstimateUnknown,
		/**Velocity Estimate is not present*/
		EVelEstimateNotPresent,
		/**Horizontal velocity is included*/
		EHorzVelPresent,
		/**Horizontal and vertical velocity is included*/
		EHorzWithVertVelPresent,
		/**Horizontal velocity with uncertainty is included*/
		EHorzVelWithUncertPresent,
		/**Horizontal and vertical velocity with uncertainty is included*/
		EHorzWithVertVelAndUncertPresent,
		};

	/**This contains the measurement quantities of the UE*/
	union TMeasurementQuantityV1
		{
	public:
		/**
		@see 3GPP TS 25.133.
		@see 3GPP TS 25.123.
		*/
		TUint8	iCpichEcN0;
		/**
		@see 3GPP TS 25.133.
		@see 3GPP TS 25.123.
		*/
		TUint8	iCpichRscp;
		/**Measurement path loss in dB.*/
		TUint8	iPathLoss;
		/**Extra for future use*/
		TBool	iSpare;
		};

	/**This class contains the current cell informations in TDD mode*/
	class TTddV1
		{
	public:
		/**
		Time slot Interference on Signal Code Power
		@see 3GPP TS 25.123
		*/
		TUint8	iTimeSlotIscp;
		/**Primary Common Control Physical CHannel received signal code power*/
		TUint8	iPrimaryCcpchRscp;
		};

	/**This class contains the information in FDD mode*/
	class TFddV1
		{
	public:
		/**Holds the measurement quantities of the UE*/
		TMeasurementQuantityV1	iMeasurementQuantity;
		/**Holds the field that would be populated in iMeasurementQuantity*/
		TMeasQnty	iMeasQntyStatus;
		};

	/**This contains the current cell information in specific modes - FDD/TDD*/
	union TCurrentCellV1 
		{
		/**Current cell information in FDD mode*/
		TFddV1	iFdd;
		/**Current cell information in TDD mode*/
		TTddV1	iTdd;
		};

	/**This contains the type of sfn-sfn observed time difference*/
	union TSfnSfnObsTimeDifferenceV1
		{
		/**Sfn-Sfn observed time difference -type1*/
		TUint16	iSfnSfnObsTimeDiff1;
		/**Sfn-Sfn observed time difference -type2*/
		TUint16	iSfnSfnObsTimeDiff2;
		};

	/**This class contains the FDD mode information of monitored cells*/
	class TMonitoredCellFddV1
		{
	public:
		/**Primary Common Control Physical CHannel information*/
		TUint16		iPrimaryCpichInfo;
		/**Holds the measurement quantities of the UE*/
		TMeasurementQuantityV1 iMeasurementQuantity;
		/**Holds the field that would be populated in iMeasurementQuantity*/
		TMeasQnty	iMeasQntyStatus;
		};

	/**This class contains the TDD mode information of monitored cells*/
	class TMonitoredCellTddV1
		{
	public:
		/**Cell identification*/
		TUint8	iCellParametersID;
		/**Primary Common Control Physical CHannel received signal code power*/
		TUint8	iPrimaryCcpchRscp;
		};

	/**This contains the monitored cells information in specific mode -  FDD/TDD*/
	union TMonitoredCellModeSpecificInfoV1
		{
		/**Monitored Cell information in FDD mode*/
		TMonitoredCellFddV1	iMonitoredCellFdd;
		/**Monitored Cell information in TDD mode*/
		TMonitoredCellTddV1	iMonitoredCellTdd;
		};

	/**This class contains the measured results for monitored cells on Random Access Channel*/
	class TMonitoredCellRachResultV1
		{
	public:
		/**Holds the sfn-sfn observed time difference*/
		TSfnSfnObsTimeDifferenceV1 iSfnSfnObsTimeDiff;
		/**Holds the monitored cells specific info mode - FDD/TDD*/
		TMonitoredCellModeSpecificInfoV1 iMonitoredCellModeSpecificInfo;
		/**ETrue indicates iMonitoredCellModeSpecificInfo is iMonitoredCellFdd.
		EFalse indicates iMonitoredCellModeSpecificInfo is iMonitoredCellTdd*/
		TBool	iSfnSfnObsTimeDiffStatus;
		};
	/**
	Horizontal velocity is characterised by the horizontal speed and bearing. 
	The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE. 
	The bearing provides the direction of the horizontal component of velocity taken clockwise from North.
	@see 3GPP TS 23.032
	*/
	class THorzVelocityV1
		{
	public:
		/**The direction of movement is given in degrees where '0' represents North, '90' represents East, etc.*/
		TUint16		iBearing;
		/**The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE*/
		TUint16		iHorzSpeed;
		};

	/**This enum holds vertical speed direction*/
	enum TVertSpeedDirection
		{
		/**Speed direction unknown*/
		ESpeedDirectionUnknown,
		/**Upward direction*/
		EUpward,
		/**Downward direction*/
		EDownward
		};

	/**
	Horizontal velocity is characterised by the horizontal speed and bearing. 
	The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE. 
	The vertical speed and direction provides the component of velocity of a UE in a vertical direction.
	The bearing provides the direction of the horizontal component of velocity taken clockwise from North.
	@see 3GPP TS 23.032
	*/
	class THorzWithVertVelocityV1
		{
	public:
		/**Direction of vertical speed*/
		TVertSpeedDirection	iVertSpeedDirection;
		/**The direction of movement is given in degrees where '0' represents North, '90' represents East, etc.*/
		TUint16		iBearing;
		/**The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE*/
		TUint16		iHorzSpeed;
		/**The vertical speed and direction provides the component of velocity of a UE in a vertical direction.*/
		TUint8		iVertSpeed;
		};

	/**
	Horizontal velocity with uncertainty is characterised by a horizontal speed and bearing,
	giving a horizontal velocity vector V, and an uncertainty speed s.
	@see 3GPP TS 23.032
	*/
	class THorzVelocityWithUncertaintyV1
		{
	public:
		/**	The direction of movement is given in degrees where '0' represents North, '90' represents East, etc.*/
		TUint16		iBearing;
		/**The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE*/
		TUint16		iHorzSpeed;
		/**
		Horizontal speed uncertainty.
		*/
		TUint8		iHorzSpeedUncertainty;
		};

	/**
	Horizontal and vertical velocity with uncertainty is characterised by a horizontal speed and bearing, 
	giving a horizontal velocity vector Vx,y, a vertical speed and direction giving a vertical velocity component Vz,
	and uncertainty speeds s1 and s2. 
	@see 3GPP TS 23.032
	*/
	class THorzWithVertVelocityAndUncertaintyV1
		{	
	public:
		/**
		The direction of movement is given in degrees where '0' represents North, '90' represents East, etc.
		*/
		TUint16		iBearing;
		/**The horizontal speed gives the magnitude of the horizontal component of the velocity of a UE*/
		TUint16		iHorzSpeed;
		/**The vertical speed and direction provides the component of velocity of a UE in a vertical direction.*/
		TUint8		iVertSpeed;
		/**Horizontal speed uncertainty.*/
		TUint8		iHorzSpeedUncertainty;
		};

	/**
	This class contains the possible ways of velocity estimates
	@see 3GPP TS 23.032
	*/
	union TVelocityEstimateV1
		{
		/**Horizontal velocity*/
		THorzVelocityV1					iHorzVelocity;
		/**Horizontal velockity and vertical velocity*/
		THorzWithVertVelocityV1			iHorzWithVertVelocity;
		/**Horizontal velocity with uncertainty*/
		THorzVelocityWithUncertaintyV1	iHorzVelocityWithUncertainty;
		/**Horizontal and vertical velocity with uncertainty*/
		THorzWithVertVelocityAndUncertaintyV1	iHorzWithVertVelocityAndUncertainty;
		};

	/**This class contains the measured results on Random Access Channel*/
	class TMeasuredResultsOnRachV1
		{
	public:
		/**Current cell information*/
		TCurrentCellV1	iCurrentCell;
		/**Monitored Cell information*/
		TMonitoredCellRachResultV1	iMonitoredCellsRachList[KMaxMonitoredCells];
		/**ETrue indicates iCurrentCell is iFdd.
		EFalse indicates iCurrentCell is iTdd*/
		TBool	iCurrentCellStatus;
		};

	/**
	Identifies the channel in combination with the Midamble shift and slot number.
	It is not used in 1.28 Mcps TDD and may be set to either value and should be ignored by the receiver.
	*/
	enum TBurstType
		{
		/**Burst type 1*/
		EType1,
		/**Burst type 2*/
		EType2
		};

	/**This class contains UE positioning estimates specific to TDD*/
	class TPosEstimateTddV1
		{
	public:
		/**Identifies the channel in combination with the Midamble shift and slot number.*/
		TBurstType	iBurstType;
		/**Midamble shift*/
		TUint8	iMidambleShift;
		/**
		This member data is present only if no IPDL scheme is configured in the reference cell.
		Otherwise the slot is defined by the IPDL configuration.
		*/
		TUint8	iTimeSlotNumber;
		/**
		Cell identification
		*/
		TUint8	iCellParametersID;
		};

	/**This class contains UE positioning estimates specific to FDD/TDD*/
	union TPosEstimateModeSpecificInfoV1
		{
		/**Identifies the reference cell for the GPS TOW-SFN relationship.*/
		TUint16		iPrimaryCpichInfo;
		/**Holds the cell and channel identification*/
		TPosEstimateTddV1	iCellAndChannelID;
		};

	/**This class contains the cell timing information*/
	class TCellTimingV1
		{
	public:
		/**
		SFN during which the position was calculated.
		*/
		TUint16		iSfn;
		/**Holds the UE positioning estimates specific to mode - FDD or TDD*/
		TPosEstimateModeSpecificInfoV1	iPosEstimateModeSpecificInfo;
		/**ETrue indicates iPosEstimateModeSpecificInfo is iPrimaryCpichInfo.
		EFalse indicates iPosEstimateModeSpecificInfo is iCellAndChannelID.*/
		TBool	iPosEstimateModeStatus;
		};

	/**This class captures the GPS measurement specific to FDD or TDD*/
	union TGpsMeasModeSpecificInfoV1
		{
		/**Frequency Division Duplex identification*/
		TUint16	iFddRefID;
		/**Time Division Duplex identification*/
		TUint8	iTddRefID;
		};

	/**This class contains results of the GPS reference time*/
	class TUtranGpsRefTimeResultV1
		{
	public:
		/**UE-GPS timing of cell ms-part*/
		TUint16		iMsPart;
		/**UE-GPS timing of cell ls-part*/
		TUint16		iLsPart;
		/**Holds the GPS measurement specific to FDD or TDD*/
		TGpsMeasModeSpecificInfoV1	iGpsMeasModeSpecificInfo;
		/**Cell System Frame Number*/
		TUint16		iSfn;
		/**ETrue indicates iGpsMeasModeSpecificInfo is iFddRefID. 
		 EFalse indicates iGpsMeasModeSpecificInfo is iTddRefID*/
		TBool	iGpsMeasModeStatus;
		};

	/**This union contains the UE positioning reference time*/
	union TPosReferenceTimeV1
		{
		/**Contains the results of GPS reference time*/
		TUtranGpsRefTimeResultV1	iUtranGpsRefTimeResult;
		/**Contains the GPS reference time*/
		TUint16		iGpsRefTimeOnly;
		};
	
	/**
	This class contains the information of ellipsoid.
	It consists of a latitude and a longitude.
	@see 3GPP TS 23.032
	*/
	class TEllipsoidPointV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**
		A north/south angular measurement of position relative to the equator, 
		in the meridian plane which contains the earth's rotation axis
		*/
		TUint16	iLatitude;
		/**
		An east/west angular measurement of position in relation to the Prime Meridian. 
		The angle between the two great circles, one being the Prime (or Greenwich) Meridian 
		and the other a meridian passing through the point of interest.
		*/
		TInt16	iLongitude;
		};

	/**
	It is characterised by the co-ordinates of an ellipsoid point (the origin) and a distance r
	@see 3GPP TS 23.032
	*/
	class TEllipsoidPointUncertCircleV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**
		A north/south angular measurement of position relative to the equator, 
		in the meridian plane which contains the earth's rotation axis
		*/
		TUint16	iLatitude;
		/**
		An east/west angular measurement of position in relation to the Prime Meridian. 
		The angle between the two great circles, one being the Prime (or Greenwich) Meridian 
		and the other a meridian passing through the point of interest.
		*/
		TInt16	iLongitude;
		/**Uncertainty code*/
		TUint8	iUncertaintyCode;
		};

	/**
	It is characterised by the co-ordinates of an ellipsoid point (the origin), 
	distances r1 and r2 and an angle of orientation A
	@see 3GPP TS 23.032
	*/
	class TEllipsoidPointUncertEllipseV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**
		A north/south angular measurement of position relative to the equator, 
		in the meridian plane which contains the earth's rotation axis
		*/
		TUint16	iLatitude;
		/**
		An east/west angular measurement of position in relation to the Prime Meridian. 
		The angle between the two great circles, one being the Prime (or Greenwich) Meridian 
		and the other a meridian passing through the point of interest.
		*/
		TInt16	iLongitude;
		/**Uncertainty semi major axis*/
		TUint8	iUncertaintySemiMajor;
		/**Uncertainty semi minor axis*/
		TUint8	iUncertaintySemiMinor;
		/**Orientation of major axis*/
		TUint8	iOrientationMajorAxis;
		/**The confidence by which the position of a target entity is known to be within the shape description*/
		TUint8	iConfidence;
		};

	/**
	The description of an ellipsoid point with altitude is that of a point at a specified distance 
	above or below a point on the earth's surface. This is defined by an ellipsoid point 
	with the given longitude and latitude and the altitude above or below the ellipsoid point.
	@see 3GPP TS 23.032
	*/
	class TEllipsoidPointAltitudeV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**
		A north/south angular measurement of position relative to the equator, 
		in the meridian plane which contains the earth's rotation axis
		*/
		TUint16	iLatitude;
		/**
		An east/west angular measurement of position in relation to the Prime Meridian. 
		The angle between the two great circles, one being the Prime (or Greenwich) Meridian 
		and the other a meridian passing through the point of interest.
		*/
		TInt16	iLongitude;
		/**Direction of altitude*/
		TAltDirection	iAltDirection;
		/**Degree of altitude*/
		TUint16	iAltitude;
		};
	
	/**
	characterised by the co-ordinates of an ellipsoid point with altitude, distances r1 (the "semi-major uncertainty"),
	r2 (the "semi-minor uncertainty") and r3 (the "vertical uncertainty") and an angle of orientation A 
	(the "angle of the major axis")
	@see 3GPP TS 23.032
	*/
	class TEllipsoidPointAltitudeEllipseV1
		{
	public:
		/**Specifies the sign - North/South*/
		TLatitudeSign	iLatitudeSign;
		/**
		A north/south angular measurement of position relative to the equator, 
		in the meridian plane which contains the earth's rotation axis
		*/
		TUint16	iLatitude;
		/**
		An east/west angular measurement of position in relation to the Prime Meridian. 
		The angle between the two great circles, one being the Prime (or Greenwich) Meridian 
		and the other a meridian passing through the point of interest.
		*/
		TInt16	iLongitude;
		/**Direction of altitude*/
		TAltDirection	iAltDirection;
		/**Degree of latitude*/
		TUint16	iAltitude;
		/**Uncertainty semi major axis*/
		TUint8	iUncertaintySemiMajor;
		/**Uncertainty semi minor axis*/
		TUint8	iUncertaintySemiMinor;
		/**Orientation of major axis*/
		TUint8	iOrientationMajorAxis;
		/**The confidence by which the position of a target entity is known to be within the shape description*/
		TUint8	iConfidence;
		};

	/**This union holds the possible forms of position estimate of the UE that can be captured.*/
	union TPositionEstimateV1
		{
		/**
		The description of an ellipsoid point is that of a point
		on the surface of the ellipsoid, and consists of a latitude and a longitude.
		@see 3GPP TS 23.032
		*/
		TEllipsoidPointV1					iEllipsoidPoint;
		/**
		It is characterised by the co-ordinates of an ellipsoid point (the origin) and a distance r
		@see 3GPP TS 23.032
		*/
		TEllipsoidPointUncertCircleV1		iEllipsoidPointUncertCircle;
		/**
		It is characterised by the co-ordinates of an ellipsoid point (the origin), 
		distances r1 and r2 and an angle of orientation A
		@see 3GPP TS 23.032
		*/
		TEllipsoidPointUncertEllipseV1		iEllipsoidPointUncertEllipse;
		/**
		The description of an ellipsoid point with altitude is that of a point at a specified distance 
		above or below a point on the earth's surface. This is defined by an ellipsoid point 
		with the given longitude and latitude and the altitude above or below the ellipsoid point.
		@see 3GPP TS 23.032
		*/
		TEllipsoidPointAltitudeV1			iEllipsoidPointAltitude;
		/**
		characterised by the co-ordinates of an ellipsoid point with altitude, distances r1 (the "semi-major uncertainty"),
		r2 (the "semi-minor uncertainty") and r3 (the "vertical uncertainty") and an angle of orientation A 
		(the "angle of the major axis")
		@see 3GPP TS 23.032
		*/
		TEllipsoidPointAltitudeEllipseV1	iEllipsoidPointAltitudeEllipsoide;
		};

	/**This contains the positioning estimate reference time*/
	union TPosEstimateRefTime
		{
		/**Contains results of the GPS reference time*/
		TUtranGpsRefTimeResultV1	iUtranGpsRefTimeResult;
		/**Contains the GPS reference time */
		TUint16		iGpsRefTimeOnly;
		/**Contains the cell timing*/
		TCellTimingV1	iCellTiming;
		};

	/**
	Provides the position estimate from the UE to the network, 
	if the UE is capable of determining its own position.
	*/
	class TUePosPositionEstimateInfoV1
		{
	public:
		/**UE positioning estimate reference time*/
		TPosEstimateRefTime	iPosEstimateRefTime;
		/**Holds the UE's position estimate
		@see TPositionEstimateV1
		*/
		TPositionEstimateV1	iPostionEstimate;
		/**Holds the field that would be populated in iPosEstimateRefTime*/
		TPosEstimateInfo	iPosEstimateRefTimeStatus;
		/**Holds the field that would be populated in iPosEstimate*/
		TPosEstimateInfo	iPosEstimateStatus;
		};
	
	/**This enum contains the multipath indicators*/
	enum TMultipathIndicator
		{
		/**
		Multipath indicator unknown
		This is an invalid indicator. 
		*/
		EMPUnknown,
		/**Not measured*/
		ENm,
		/**MP error < 5m*/
		ELow,
		/**5m < MP error < 43m*/
		EMedium,
		/**MP error > 43m*/
		EHigh
		};

	/**This class contains the GPS measurement parameters of the UE*/
	class TGpsMeasMeasurementParamV1
		{
	public:
		/**Satellite Identification*/
		TUint8		iSatID;
		/**
		The estimate of the carrier-to-noise ratio of the received signal from the particular 
		satellite used in the measurement. It is given in units of dB-Hz (typical levels will 
		be in the range of 20 - 50 dB-Hz).
		*/
		TUint8		iCN0;
		/**
		It is the instantaneous frequency difference between the receiver's internal oscillator 
		and the received carrier from the satellite. Hz, scale factor 0.2.
		*/
		TInt16		iDoppler;
		/**
		Unit in GPS chips.
		Whole value of the UE GPS code-phase measurement, where increasing binary values of the field 
		signify increasing measured pseudoranges.
		*/
		TUint16		iWholeGpsChips;
		/**
		The UE GPS code-phase measurement is divided into the fields "Whole GPS Chips" and "Fractional GPS Chips".
		Scale factor 2-10 Fractional value of the UE GPS code-phase measurement.
		*/
		TUint16		iFractionalGpsChips;
		/**
		Contains the possible multipath indicators. Multipath error is usually caused by one path being bounced or 
		reflected. The impact on a pseudo-range measurement may be up to a few metres. In the case of carrier phase,
		this is of the order of a few centimetres.
		*/
		TMultipathIndicator	iMultipathIndicator;
		/**
		A distance measurement based on the correlation of a satellite's transmitted code (may be the C/A-Code or 
		the encrypted P-Code) and the local receiver's reference code (for that PRN satellite number), 
		that has not been corrected for errors in synchronisation between the transmitter's clock and the receiver's clock.
		Hence a pseudo-range measurement is a time-error biased distance measurement.
		*/
		TUint8		iPseudorangeRmsError;
		};

	/**This class contains the GPS measurement parameters and the positioning reference time*/
	class TUePosGpsMeasurementResultsV1
		{
	public:
		/**UE positioning reference time*/
		TPosReferenceTimeV1	iPosGpsMeasRefTime;
		/**Holds the GPS measurement parameters from all the active satellites*/
		TGpsMeasMeasurementParamV1	iGpsMeasurementParamList[KMaxSat];
		/**ETrue indicates TPosReferenceTimeV1::iUtranGpsRefTimeResult is populated. 
		 EFalse indicates TPosReferenceTimeV1::iGpsRefTimeOnly is populated*/
		TBool	iPosGpsMeasRefTimeStatus;
		};

	/**
	This enum lists all the possible errors that UE can report to the network
	*/
	enum TPosErrorCause
		{
		/**
		Error Cause Unknown. This is an invalid error cause and is set if the UE does not set with 
		any of the underlying valid error causes
		*/
		EErrorCauseUnknown,
		/**Indicates that enought number of GPS satellites are healthy and active.*/
		ENotEnoughGpsSatellites,
		/**Assistance data required to compute location of the UE is missing in the measurement control.
		If the Additional data request flag is true in the measurement control only then additional assistance
		data can be requested otherwise measurements need to be done using the existing assistance data
		@see TGpsAddlAssistDataReqV1
		@see TUePosReportingQuantityV1
		 */
		EAssistanceDataMissing,
		/**
		Cell Frames Timings are not accomplished
		*/
		ENotAccomplishedGpsTimingOfCellFrames,
		/**
		UE can set this error in case other than the above mentioned is encountered 
		*/
		EUndefinedError,
		/**
		UE denies Location information
		*/
		ERequestDeniedByUser,
		};

	/**
	This class contains the positioning errors that might have encountered during 
	measurement of location of the UE.
	*/
	class TUePosError
		{
	public:
		/**Indicates the error cause encountered while computing GPS Assistance data*/
		TPosErrorCause		iPosErrorCause;
		/**If error cause is "Assistance Data Missing" and iAddlAssistanceDataReq is set to ETrue then
		then this member shall indicate what additional assistance data is needed.
		If iAddlAssistanceDataReq is set to EFalse then existing assistance data is used to compute location
		information of the UE.
		@see TUePosReportingQuantityV1::iAddlAssistanceDataReq*/
		TGpsAddlAssistDataReqV1	iGpsAddlAssistDataReq;
		};

	/**
	This class contains the measurement results computed by the UE.
	*/
	class TUePosMeasuredResultsV1
		{
	public:
		/**The purpose of this is to provide the position estimate from the UE to the network, 
		if the UE is capable of determining its own position.*/
		TUePosPositionEstimateInfoV1	iUePosPositionEstimateInfo;
		/**Contains the GPS measurement parameters and the positioning reference time*/
		TUePosGpsMeasurementResultsV1	iUePosGpsMeasurement;
		/**Indicates the error cause and/or additional assistance data is required*/
		TUePosError						iUePosError;
		/**
		ETrue indicates some error has encountered. iUePosError will be populated.
		EFalse indicates Gps Assistance Data is received and no error has encountered while processing.
		Hence iUePosPositionEstimateInfo and iUePosGpsMeasurement will be populated
		*/
		TBool	iPosErrorStatus;
		};

	/**Contains the measured location information of the UE*/
	union TMeasuredResultsV1
		{
		/**
		This member either contains the measurement results or the error that might have 
		encountered during measurements.
		*/
		TUePosMeasuredResultsV1		iTUePosMeasuredResults;
		/**
		A spare member for future use.
		*/
		TBool						iSpare;
		};

	/**
	This class contains the measurement report expected as response to the measurement control sent by the 
	network. Veloctiy estimates are included if requested in measurement control.
	*/
	class TMeasurementReportV7 : public RMobilePhone::TMultimodeType
		{
	public:
		IMPORT_C TMeasurementReportV7();
	public:
		/**A reference number that should be used by the UTRAN when setting up, 
		modifying or releasing the measurement and by the UE in the measurement report.
		*/
		TUint8 iMeasurementIdentity;
		/**Contains the measured location information of the UE*/
		TMeasuredResultsV1 iMeasuredResults;
		/**Contains the measured results on Random Access Channel*/
		TMeasuredResultsOnRachV1	iMeasuredResultsOnRach;
		/**Contains the velocity estimates of the UE*/
		TVelocityEstimateV1		iVelocityEstimate;
		/**
		Indicates the populated member in iVelocityEstimate if velocity estimate is computed.
		Otherwise indicates that velocity estimate is not computed.
		*/
		TVelEstimate	iVelEstimateStatus;
		};
	/**
	A typedef'd packaged TMeasurementReportV7 for passing through a
	generic API method.

	@internalAll
	*/
	typedef TPckg<TMeasurementReportV7> TMeasurementReportV7Pckg;
	
	//*********************************************//	
	//  Measurement Control Failure data structure //
	//*********************************************//

	/**
	This enum contains the list of errors that the UE can specify.
	The Measurement control failure is caused only when the the UE 
	cannot initiate a measurement as instructed by the network.
	*/
	enum TMeasurementControlFailure
		{
		/**
		Unknown Measurement Control Failure.
		This is an invalid failure state whic will be set if the UE does not set with the 
		underlying valid error reasons.
		*/
		EControlFailureUnknown,
		/**Indicates ASN1.0 encoding is incorrect*/
		EAsn1ViolationOrEncoding,
		/**Messsgae type specified is not existent*/
		EMsgTypeNonExistent,
		/**Message is not compatible*/
		EMsgNotCompatibleWithReceiverState,
		/**Information sent cannot be understood*/
		EIeValueNotComprehend,
		/**Information expected is not present*/
		EInformationElementMissing,
		/*Message extension cannot be understood*/
		EMsgExtnNotComprehend
		}; 
		
	/**
	This enum contains the possible domains used by MOLR 
	*/
	enum TDomain
   		{
		/**Packet switch domain is the default domain that will be used by Molr*/
   		EPacketSwitchedDomain,
		/**UE shall set the domain to Circuit switch whenever Molr is intended to use it*/
  	 	ECircuitSwitchedDomain
   		};

	IMPORT_C void NotifyMtlr(TRequestStatus& aReqStatus,TDes8& aNotifyMtlr);
	IMPORT_C void SendMtlrResponse(TRequestStatus& aReqStatus,const TMtlrResponse aMtlrResponse);
	IMPORT_C void SendMtlrResponse(TRequestStatus& aReqStatus,const TMtlrError aMtlrResponse);
	IMPORT_C void SendMtlrResponse(TRequestStatus& aReqStatus,const TMtlrReject aMtlrResponse);
    IMPORT_C void SendMolr(TRequestStatus& aReqStatus,const TDesC8& aStartMolr,TDes8& aMolrReturnResult);
	IMPORT_C void NotifyMeasurementControl(TRequestStatus& aReqStatus,TDes8& aMeasurementControl);
	IMPORT_C void SendMeasurementReport(TRequestStatus& aReqStatus,const TDesC8& aMeasurementReport);
	IMPORT_C void SendMeasurementReport(TRequestStatus& aReqStatus,const TMeasurementControlFailure aMeasurementControlFailure);
	IMPORT_C TInt SetLcsDomain(const TDomain aDomain);		
private:
	void ConstructL();
	void Destruct();
private:
	/**
	Pointer Holder for the RMobileLocationServices sub-session requests.
	*/
	CMobileLocationServicesPtrHolder* iMmPtrHolder;
	};

class RTelHelper
    {
    public:
    static RTelSubSessionBase::TCalledFunction GetCalledFunction();
    static void SetCallStatus( RMobileCall::TMobileCallStatus aStatus );
    static void SetCallEvent( RMobileCall::TMobileCallEvent aCallEvent );
    static void SetConfEvent( RMobileConferenceCall::TMobileConferenceEvent aConfEvent );
    static void SetConfStatus( RMobileConferenceCall::TMobileConferenceStatus aConfStatus );
    static void SetCallDirection( RMobileCall::TMobileCallDirection aDirection );
    static void SetCallEmergency( TBool aVal );
    static void SetRemoteIdStatus( RMobileCall::TMobileCallRemoteIdentityStatus aStatus );
    };

#endif // __ETELMM_H__

