diff -r 000000000000 -r f0cf47e981f9 mmsharing/mmshavailability/tsrc/ut_availability/Stubs/inc/etelmm.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmsharing/mmshavailability/tsrc/ut_availability/Stubs/inc/etelmm.h Thu Dec 17 08:44:37 2009 +0200 @@ -0,0 +1,12666 @@ +/* +* 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 +#include +#include +#include + + +/** +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 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 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 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 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 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 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 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 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 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 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 iManufacturer; + /** Phone model identification, in character string format. */ + TBuf iModel; + /** Phone revision identification, in character string format. */ + TBuf iRevision; + /** Phone serial number (IMEI or ESN), in character string format. */ + TBuf 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 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; + + void DoNotifyModeChange( TMobilePhoneNetworkMode aNetworkMode, TInt aErrorCode ); + void CancelAsyncRequest(TInt aReqToCancel) const; + + mutable TMobilePhoneNetworkMode* iNetworkMode; + mutable TRequestStatus* iReqStatus; + + +/** 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 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 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 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 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 iSPName; + TBuf iPLMNField; + }; + +/** A typedef'd packaged TMobilePhoneServiceProviderNameV2 for passing through +a generic API function member. */ + typedef TPckg 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 iOtherNames; + }; + + /** + Packaging typedef for TMobilePhoneNetworkNameV3 class. + */ + typedef TPckg 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 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 iAdditionalInfo; + }; + + /** + Packaging typedef for TMobilePhoneSendSSRequestV3 class. + */ + typedef TPckg 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 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 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 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 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 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 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 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 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 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 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 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 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 iLabel; + }; + + /** + A typedef'd packaged TSmartCardApplicationInfoV5 for passing through a generic API + function member. + */ + typedef TPckg 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 iEapTypeList; + }; + + /** + A typedef'd packaged TEapUiccApplicationInfoV6 for passing through + a generic API function member. + + @see RMobilePhone::GetSmartCardApplicationInfo() + */ + typedef TPckg 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 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 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 iLabel; + }; + + /** A typedef'd packaged TUSimApplicationInfoV2 for passing through a generic API + function member. + + @deprecated 9.1 Use @see TSmartCardApplicationInfoV5 instead. + */ + typedef TPckg 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 iNotify; + }; + + typedef TPckg 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 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 iApn; + }; + + typedef TPckg 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 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 TIMPU; + /** typedef for Internet Multimedia Private Identity*/ + typedef TBuf8 TIMPI; + /** typedef for Home Network Domain Name*/ + typedef TBuf8 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 iAUTN; + /** holds value of network challenge RAND */ + TBuf8 iRAND; + /** holds result RES of AUTHENTICATE command when it's successfull*/ + TBuf8 iRES; + /** holds value of session key Integrity Key */ + TBuf8 iIK; + /** holds value of session key Cipher Key */ + TBuf8 iCK; + /** holds value of Authentication Token when AUTHENTICATE fails*/ + TBuf8 iAUTS; + }; + + /** packaged version of TImsAuthenticateDataV5, used when this structure has to be passeed via IPC*/ + typedef TPckg 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 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 iKc; + }; + + /** + Packaged version of TSmartCardAuthenticateDataV6, used when this + structure has to be passeed via IPC. + */ + typedef TPckg 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ + static 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 iCallingName; + }; + +/** A typedef'd packaged TMobileCallRemotePartyInfoV1 for passing through a generic +API function member. */ + typedef TPckg 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. */ + static 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 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 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 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 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 TPckgTEtel3rdPartyMobileCallParamsV1Pckg; + + +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 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 TMobileSmsGsmTpdu; +/** A typedef'd buffer for CDMA message data. */ + typedef TBuf8 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 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 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 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 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 iText; + }; + +/** A typedef'd packaged TMobileSmspEntryV1 for passing through a generic API member +function. */ + typedef TPckg 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 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 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 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 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 TGsmBroadcastMessageData; + /** Buffer for CDMA messages. TBroadcastPageData should be used instead. */ + typedef TBuf8 TCdmaBroadcastMessageData; + /** Buffer for WCDMA messages. TBroadcastPageData should be used instead. */ + typedef TBuf8 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 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 TMobileUssdAttributesV1Pckg; + + /***********************************************************************************/ + // + // Receiving USSD messages + // + /***********************************************************************************/ + + enum + { + KGsmUssdDataSize = 160 + }; + +/** A typedef'd buffer to hold the message data. */ + typedef TBuf8 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 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 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 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 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 iData; + }; + + /** A typedef'd packaged TMobileNamEntryV1 for passing through a generic API member + function. */ + typedef TPckg 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 iData; + }; + + /** A typedef'd packaged TMobileNamEntryV4 for passing through a generic API member + function. */ + typedef TPckg 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 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 iText; + }; + +/** A typedef'd packaged TMobileONEntryV1 for passing through a generic API member +function. */ + typedef TPckg 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 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 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 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 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 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 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 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 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 iEapId; + }; + + /** + A typedef'd packaged TEapUserIdentityV6 for passing through a + generic API method. + + @publishedPartner + @prototype + */ + typedef TPckg 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 iEapKey; + }; + + /** + A typedef'd packaged TEapKeyV6 for passing through a generic API + method. + + @publishedPartner + @prototype + */ + typedef TPckg 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 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 TLcsClientNameBuffer; + /** + A typedef'd buffer which holds the RequestorId String. + @see KLcsMaxRequestorIdStringSize + */ + typedef TBuf8 TLcsRequestorIdString; + /** + A typedef'd buffer which holds the Gps Assistance Data. + @see KLcsMaxGpsAssistanceDataSize + */ + typedef TBuf8 TGpsAssistanceData; + /** + A typedef'd buffer which holds the External ClientId. + @see KLcsMaxClientExternalIdSize + */ + typedef TBuf8 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 TLcsLocationEstimate; + /** + A typedef'd buffer which holds the Velocity Estimate. + @see KLcsMaxVelocityEstimateSize + */ + typedef TBuf8 TLcsVelocityEstimate; + /** + A typedef'd buffer which holds the GpsAssistanceData type. + @see KLcsMaxGpsAssistanceDataSize + */ + typedef TBuf8 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 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 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 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 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 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; + }; + +#endif // __ETELMM_H__ +