diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/mw/rconnmon.h --- a/epoc32/include/mw/rconnmon.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/mw/rconnmon.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,2727 @@ -rconnmon.h +/* +* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: RConnectionMonitor provides an interface for an application to +* get information about active data connection. It also provides +* a way to close any connection or all the connections. +* +*/ + +#ifndef __CONNECTIONMONITOR_H +#define __CONNECTIONMONITOR_H + +#include + + +// =========================================================================== +// TInt attribute constants, used by GetIntAttribute, SetIntAttribute. +// =========================================================================== +// +/** Bearer, defined in TConnMonBearerType. +*/ +const TUint KBearer = 1; +/** Network status, defined in TConnMonNetworkStatus. +*/ +const TUint KNetworkStatus = 2; +/** Connection status, progress constants are from nifvar.h. +*/ +const TUint KConnectionStatus = 3; +/** Protocol, defined in TConnMonProtocolType. +*/ +const TUint KProtocolType = 4; +/** Network registration values defined in TConnMonNetworkRegistration. +*/ +const TUint KNetworkRegistration = 5; +/** Signal strength in dBm. +*/ +const TUint KSignalStrength = 6; +/** WLAN mode, defined in TConnMonNetworkMode. +*/ +const TUint KNetworkMode = 7; +/** WLAN connection security mode, defined in TConnMonSecurityMode. +*/ +const TUint KSecurityMode = 8; +/** Bearer information, defined in TConnMonBearerInfo. +*/ +const TUint KBearerInfo = 9; +/** Acceptable WLAN scan cache age in seconds. Set to -1 to use device +default. Only has meaning if KWlanScanMaxDelay is set to 0. +*/ +const TUint KWlanScanCacheLifetime = 10; +/** QoS - Not supported. +*/ +const TUint KTrafficClass = 30; +/** QoS - Not supported. +*/ +const TUint KDeliveryOrder = 31; +/** QoS - Not supported. +*/ +const TUint KErroneousSDUDelivery = 32; +/** QoS - Not supported. +*/ +const TUint KResidualBitErrorRatio = 33; +/** QoS - Not supported. +*/ +const TUint KSDUErrorRatio = 34; + + +// =========================================================================== +// TUint attribute constants, used by GetUintAttribute, SetUintAttribute. +// =========================================================================== +// +/** Downlink data in bytes. +*/ +const TUint KDownlinkData = 100; +/** Uplink data in bytes. +*/ +const TUint KUplinkData = 101; +/** Used IAP ID. +*/ +const TUint KIAPId = 102; +/** Network ID. +*/ +const TUint KNetworkIdentifier = 103; +/** WLAN transmit power in mW. +*/ +const TUint KTransmitPower = 104; +/** Current network mode, defined in TConnMonMobilePhoneNetworkMode. +*/ +const TUint KMobilePhoneNetworkMode = 105; +/** QoS - Not supported. +*/ +const TUint KMaximumBitrateDownlink = 130; +/** QoS - Not supported. +*/ +const TUint KMaximumBitrateUplink = 131; +/** QoS - Not supported. +*/ +const TUint KMaximumSDUSize = 132; +/** QoS - Not supported. +*/ +const TUint KTransferDelay = 133; +/** QoS - Not supported. +*/ +const TUint KGuaranteedBitrateDownlink = 134; +/** QoS - Not supported. +*/ +const TUint KGuaranteedBitrateUplink = 135; +/** QoS - Not supported. +*/ +const TUint KTrafficHandlingPriority = 136; +/** Enables EConnMonConnectionActivityChange events. +0 means off, minimum allowed is 5 seconds. +*/ +const TUint KActivityTimeThreshold = 150; +/** Enables EConnMonDownlinkDataThreshold events. +0 means off, minimum allowed is 4096 bytes. +*/ +const TUint KDownlinkDataThreshold = 151; +/** Enables EConnMonUplinkDataThreshold events. +0 means off, minimum allowed is 4096 bytes. +*/ +const TUint KUplinkDataThreshold = 152; +/** Enables EConnMonBearerAvailabilityChange events. +*/ +const TUint KBearerAvailabilityThreshold = 153; +/** Enables EConnMonSignalStrengthChange events. +*/ +const TUint KSignalStrengthThreshold = 154; +/** If set, disables EConnMonBearerChange events and enables +EConnMonBearerInfoChange and EConnMonBearerGroupChange events instead. +*/ +const TUint KBearerGroupThreshold = 155; +/** Acceptable delay in seconds for receiving WLAN scan results. +If set to 0 (default), KWlanScanCacheLifetime will be used. +*/ +const TUint KWlanScanMaxDelay = 160; + + +// =========================================================================== +// TBool attribute constants, used by GetBoolAttribute, SetBoolAttribute. +// =========================================================================== +// +/** Connection activity. +*/ +const TUint KConnectionActive = 200; +/** Bearer availability. +*/ +const TUint KBearerAvailability = 201; +/** Packet data availability. Can be blocked if phone call is active and no +dual transfer mode support. +*/ +const TUint KPacketDataAvailability = 202; +/** Stop a connection. +*/ +const TUint KConnectionStop = 250; +/** Stop all connections. +*/ +const TUint KConnectionStopAll = 251; + + +// =========================================================================== +// TDes attribute constants, used by GetStringAttribute, SetStringAttribute. +// =========================================================================== +// +/** Name of used IAP. +*/ +const TUint KIAPName = 300; +/** Name of used access point. +*/ +const TUint KAccessPointName = 301; +/** Used telephone number. +*/ +const TUint KTelNumber = 302; +/** Name (SSID) of used WLAN. +*/ +const TUint KNetworkName = 303; +/** WLAN name (SSID) to be used in SSID scan (KWlanSsidNetworks). +*/ +const TUint KWlanSsid = 304; + + +// =========================================================================== +// TPckgBuf attribute constants, used by GetPckgAttribute. +// =========================================================================== +// +/** Connection start time. See TConnMonTimeBuf. +*/ +const TUint KStartTime = 400; +/** All clients using a connection. See TConnMonClientEnumBuf. +*/ +const TUint KClientInfo = 401; +/** Basic WLAN scan information. See TConnMonNetworkNamesBuf. +*/ +const TUint KNetworkNames = 402; +/** Available IAP IDs. See TConnMonIapInfoBuf. +*/ +const TUint KIapAvailability = 403; +/** Deprecated. Old WLAN scan results, use KWlanNetworks instead. +*/ +const TUint KWLANNetworks = 404; +/** Available SNAP IDs. See TConnMonSNAPInfoBuf. +*/ +const TUint KSNAPsAvailability = 405; +/** Available SNAP IDs, in a more flexible way. See ConnMonIdsArrayPckg. +*/ +const TUint KAvailableSNAPsIds = 406; +/** WLAN scan results. See CConnMonWlanNetworksPtrArrayPckg. +*/ +const TUint KWlanNetworks = 407; +/** Bearer group information. See TConnMonBearerGroupInfoBuf. +*/ +const TUint KBearerGroupInfo = 408; +/** WLAN SSID scan results. Scans for WLANs with a specific SSID. +See CConnMonWlanNetworksPtrArrayPckg. +*/ +const TUint KWlanSsidNetworks = 409; +/** Information about the currently used WLAN. +See CConnMonWlanNetworksPtrArrayPckg. +*/ +const TUint KWlanCurrentNetwork = 410; +/** Beacon frames from a WLAN scan. See CConnMonWlanProbeRawBuffersPckg. +*/ +const TUint KWlanProbeRawBuffers = 411; + + +/** Base value for plug-in specific attribute IDs. +*/ +const TUint KConnMonPluginAttributeBase = 3000000; + + +/** +* Bearer type. +*/ +enum TConnMonBearerType + { + EBearerUnknown = 0, + EBearerCSD = 1, ///< CSD (GSM) + EBearerWCDMA = 2, ///< PSD (WCDMA) + EBearerLAN = 3, + EBearerCDMA2000 = 4, + EBearerGPRS = 5, + EBearerHSCSD = 6, ///< HSCSD (GSM) + EBearerEdgeGPRS = 7, + EBearerWLAN = 8, + EBearerBluetooth = 9, + EBearerVirtual = 10, + EBearerVirtualVPN = 11, + EBearerWcdmaCSD = 12, ///< CSD (WCDMA) + + EBearerExternalCSD = 30, ///< external CSD (GSM) + EBearerExternalWCDMA = 31, ///< external PSD (WCDMA) + EBearerExternalLAN = 32, + EBearerExternalCDMA2000 = 33, + EBearerExternalGPRS = 34, + EBearerExternalHSCSD = 35, ///< external HSCSD (GSM) + EBearerExternalEdgeGPRS = 36, + EBearerExternalWLAN = 37, + EBearerExternalBluetooth = 38, + EBearerExternalWcdmaCSD = 39, ///< external CSD (WCDMA) + }; + +/** +* Bearer specific general connection ID. +*/ +enum TConnMonBearerId + { + EBearerIdAll = 0, + EBearerIdGPRS = 2000000, ///< Internal/external GPRS and EdgeGPRS + EBearerIdWCDMA = 2000001, ///< Internal/external PSD (WCDMA) + EBearerIdCSD = 2000002, ///< Internal/external CSD and HSCSD (GSM) + EBearerIdGSM = 2000003, ///< Union of EBearerIdGPRS and EBearerIdCSD + EBearerIdWLAN = 2000004, + EBearerIdLAN = 2000005, + EBearerIdWcdmaCSD = 2000006, ///< Internal/external CSD (WCDMA) + EBearerIdCDMA2000 = 2000007, + EBearerIdVirtualVPN = 2000008 + }; + +/** +* Network status. +*/ +enum TConnMonNetworkStatus + { + EConnMonStatusNotAvailable = 0, + EConnMonStatusUnattached, + EConnMonStatusAttached, + EConnMonStatusActive, + EConnMonStatusSuspended + }; + +/** +* Protocol type (type of PDP). It may not be available for some +* bearers (returns EProtocolTypeUnknown). +*/ +enum TConnMonProtocolType + { + EProtocolTypeUnknown = 0, + EProtocolTypeIPv4, + EProtocolTypeIPv6, + EProtocolTypeX25, + EProtocolTypePPP, + EProtocolTypeCDPD, + EProtocolTypeIP ///< Connection uses both IPv4 and IPv6 + }; + +/** +* Asyncronous request codes. +*/ +enum TConnMonAsyncRequest + { + EConnMonGetConnectionCount = 1, + EConnMonGetIntAttribute, + EConnMonGetUintAttribute, + EConnMonGetBoolAttribute, + EConnMonGetStringAttribute, + EConnMonGetPckgAttribute + }; + +/** +* Events sent by Connection Monitor. See SDK documentation for more details. +*/ +enum TConnMonEvent + { + EConnMonCreateConnection = 1, + EConnMonDeleteConnection = 2, + EConnMonCreateSubConnection = 3, ///< Not supported + EConnMonDeleteSubConnection = 4, ///< Not supported + EConnMonDownlinkDataThreshold = 5, + EConnMonUplinkDataThreshold = 6, + EConnMonNetworkStatusChange = 7, + EConnMonConnectionStatusChange = 8, + EConnMonConnectionActivityChange = 9, + EConnMonNetworkRegistrationChange = 10, + EConnMonBearerChange = 11, + EConnMonSignalStrengthChange = 12, ///< For cellular, not WLAN + EConnMonBearerAvailabilityChange = 13, + EConnMonIapAvailabilityChange = 14, + EConnMonTransmitPowerChange = 15, ///< For WLAN + EConnMonSNAPsAvailabilityChange = 16, + EConnMonNewWLANNetworkDetected = 17, + EConnMonOldWLANNetworkLost = 18, + EConnMonPacketDataAvailable = 19, + EConnMonPacketDataUnavailable = 20, + EConnMonBearerInfoChange = 21, + EConnMonBearerGroupChange = 22, + + EConnMonPluginEventBase = 4000000 + }; + +/** +* Network registration status. Valid for CSD, GPRS and WCDMA. +*/ +enum TConnMonNetworkRegistration + { + ENetworkRegistrationNotAvailable = 0, + ENetworkRegistrationUnknown, + ENetworkRegistrationNoService, + ENetworkRegistrationEmergencyOnly, + ENetworkRegistrationSearching, + ENetworkRegistrationBusy, + ENetworkRegistrationHomeNetwork, + ENetworkRegistrationDenied, + ENetworkRegistrationRoaming + }; + +/** +* QoS. Traffic class. +*/ +enum TQosTrafficClass + { + EQosTrafficClassConversational = 1, + EQosTrafficClassStreaming, + EQosTrafficClassInteractive, + EQosTrafficClassBackground + }; + +/** +* QoS. Delivery order. +*/ +enum TQosDeliveryOrder + { + EQosDeliveryOrderYes = 1, + EQosDeliveryOrderNo + }; + +/** +* QoS. Delivery of erroneous SDUs. +*/ +enum TQosErroneousSDUDelivery + { + EQosErroneousSDUDeliveryYes = 1, + EQosErroneousSDUDeliveryNo, + EQosErroneousSDUDeliveryUnspecified + }; + +/** +* QoS. Residual bit error ratio. +*/ +enum TQosBitErrorRatio + { + EQosBERFivePerHundred = 1, + EQosBEROnePerHundred, + EQosBERFivePerThousand, + EQosBEROnePerThousand, + EQosBEROnePerTenThousand, + EQosBEROnePerMillion + }; + +/** +* QoS. SDU error ratio. +*/ +enum TQosSDUErrorRatio + { + EQosSDUErrorRatioOnePerHundred = 1, + EQosSDUErrorRatioSevenPerThousand, + EQosSDUErrorRatioOnePerThousand, + EQosSDUErrorRatioOnePerTenThousand, + EQosSDUErrorRatioOnePerHundredThousand + }; + +/** +* Client-server requests. +*/ +enum TConnMonRequests + { + EReqGetConnectionCount = 0, + EReqGetConnectionInfo = 1, + EReqGetSubConnectionInfo = 2, + EReqGetIntAttribute = 3, + EReqGetUintAttribute = 4, + EReqGetBoolAttribute = 5, + EReqGetStringAttribute = 6, + EReqGetPckgAttribute = 7, + EReqSetIntAttribute = 8, + EReqSetUintAttribute = 9, + EReqSetBoolAttribute = 10, + EReqSetStringAttribute = 11, + EReqSetPckgAttribute = 12, + EReqCancelAsyncRequest = 13, + EReqReceiveEvent = 14, + EReqCancelReceiveEvent = 15, + + EReqPluginCreateSubSession = 500, + EReqPluginCloseSubSession = 501, + EReqPluginRegisterAttribute = 502, + EReqPluginCancelRegisterAttribute = 503, + EReqPluginEvent = 504, + EReqPluginGetQuery = 505, + EReqPluginCancelGetQuery = 506, + EReqPluginAttribute = 507, + + EReqInternalSetThreshold = 600, + EReqInternalResetThreshold = 601 + }; + +/** +* WLAN connection modes. +*/ +enum TConnMonNetworkMode + { + EConnMonInfraStructure = 0, + EConnMonAdHoc = 1, + EConnMonSecureInfra = 2 + }; + +/** +* WLAN connection security modes. +*/ +enum TConnMonSecurityMode + { + EConnMonSecurityOpen = 0, + EConnMonSecurityWep = 1, + EConnMonSecurity802d1x = 2, + EConnMonSecurityWpa = 3, + EConnMonSecurityWpaPsk = 4 + }; + +/** +* Network Modes. +*/ +enum TConnMonMobilePhoneNetworkMode + { + EConnMonNetworkModeUnknown = 0, ///< Network mode is unknown + EConnMonNetworkModeUnregistered, ///< ME is not registered + EConnMonNetworkModeGsm, ///< GSM/GPRS or DCS1800 network + EConnMonNetworkModeAmps, ///< AMPS network (CDMA) + EConnMonNetworkModeCdma95, ///< CDMA (IS-95) network + EConnMonNetworkModeCdma2000, ///< CDMA (cdma2000) network + EConnMonNetworkModeWcdma, ///< WCDMA (UTRA FDD) network + EConnMonNetworkModeTdcdma ///< TD-CDMA (UTRA TDD) network (WCDMA) + }; + +/** Maximum size of a plug-in's event data. +*/ +const TUint KConnMonMaxPluginDataSize = 512; +/** Maximum size of a plug-in's attribute. +*/ +const TUint KConnMonMaxStringAttributeLength = 64; + +/** +* Package class definition for getting the TTime. +*/ +typedef TPckgBuf TConnMonTimeBuf; + +/** Maximum number of clients contained in TConnMonClientEnum class. +*/ +const TUint KConnMonMaxClientUids = 10; + +/** +* Class to contain client UIDs of a connection. +*/ +class TConnMonClientEnum + { +public: + /** + * Constructor. + */ + inline TConnMonClientEnum():iCount( 0 ) + { + } +public: + /** + * Number of UIDs in iUid array. + */ + TUint iCount; + /** + * Array for client UIDs. + */ + TUid iUid[KConnMonMaxClientUids]; + }; + +/** +* Package class definition for getting the client information. +*/ +typedef TPckgBuf TConnMonClientEnumBuf; + +/** Maximum number of WLANs contained in TConnMonNetworkNames class. +*/ +const TUint KConnMonMaxNetworkCount = 10; + +/** +* Class to contain basic WLAN information. +*/ +class TConnMonNetwork +{ +public: + /** + * Constructor. + */ + inline TConnMonNetwork():iType( 0 ), iSignalStrength( 0 ) + { + } +public: + /** + * WLAN name (SSID). + */ + TBuf8<32> iName; + /** + * WLAN mode, defined in TConnMonNetworkMode. + */ + TInt8 iType; + /** + * Signal strength in dBm. Given as absolute, correct value is negative. + */ + TUint8 iSignalStrength; + }; + +/** +* Class to contain an array of basic WLAN information. +*/ +class TConnMonNetworkNames + { +public: + /** + * Constructor. + */ + inline TConnMonNetworkNames():iCount( 0 ) + { + } + /** + * This method returns the number of WLANs contained in this class. + * + * @return Number of WLANs. + */ + inline TUint Count() + { + return iCount; + } +public: + /** + * Number of items in WLAN array. + */ + TUint iCount; + /** + * Array of WLANs. + */ + TConnMonNetwork iNetwork[KConnMonMaxNetworkCount]; + }; + +/** +* Package class definition for getting basic WLAN scan information. +*/ +typedef TPckgBuf TConnMonNetworkNamesBuf; + +/** Maximum number of IAPs contained in TConnMonIapInfo class. +*/ +const TUint KConnMonMaxIAPCount = 25; + +/** +* Class representing an IAP. +*/ +class TConnMonIap + { +public: + /** + * Constructor. + */ + inline TConnMonIap():iIapId( 0 ) + { + } +public: + /** + * IAP ID number. + */ + TUint iIapId; + }; + +/** +* Class to contain an array of IAPs. +*/ +class TConnMonIapInfo + { +public: + /** + * Constructor. + */ + inline TConnMonIapInfo():iCount( 0 ) + { + } + /** + * This method returns the number of IAPs contained in this class. + * + * @return Number of IAPs. + */ + inline TUint Count() + { + return iCount; + } +public: + /** + * Number of items in IAP array. + */ + TUint iCount; + /** + * Array of IAPs. + */ + TConnMonIap iIap[KConnMonMaxIAPCount]; + }; + +/** Package class definiton for getting available IAPs. +*/ +typedef TPckgBuf TConnMonIapInfoBuf; + +/** Maximum number of SNAPs contained in TConnMonSNAPInfo class. +*/ +const TUint KConnMonMaxSNAPsCount = 25; + +/** +* Class representing a SNAP. +*/ +class TConnMonSNAPId + { +public: + /** + * Constructor. + */ + inline TConnMonSNAPId():iSNAPId( 0 ) + { + } +public: + /** + * SNAP ID number. + */ + TUint iSNAPId; + }; + +/** +* Class to contain an array of SNAPs. +*/ +class TConnMonSNAPInfo + { +public: + /** + * Constructor. + */ + inline TConnMonSNAPInfo():iCount( 0 ) + { + } + /** + * This method returns the number of SNAPs contained in this class. + * + * @return Number of SNAPs. + */ + inline TUint Count() + { + return iCount; + } +public: + /** + * Number of items in SNAP array. + */ + TUint iCount; + /** + * Array of SNAPs. + */ + TConnMonSNAPId iSNAP[KConnMonMaxSNAPsCount]; + }; + +/** Package class definiton for getting available SNAPs. +*/ +typedef TPckgBuf TConnMonSNAPInfoBuf; + +/** +* Bearer group definition, new values will be added to the end of the +* enumeration. +*/ +enum TConnMonBearerGroup + { + EBearerGroupUnknown = 0, + EBearerGroupCellular = 0x00000001, + EBearerGroupNonCellular = 0x00000002, + EBearerGroupCellularPacket = 0x00000004, + EBearerGroupCircuitSwitched = 0x00000008, + EBearerGroup2G = 0x00000010, + EBearerGroup2GPacket = 0x00000020, + EBearerGroup3G = 0x00000040, + EBearerGroup3GPacket = 0x00000080, + EBearerGroupHSPA = 0x00000100, + EBearerGroupLANBased = 0x00000200, + EBearerGroupWLAN = 0x00000400, + EBearerGroupIPOverConnectivityProtocol = 0x00000800, + EBearerGroupWired = 0x00001000, + EBearerGroupVirtual = 0x00002000 + }; + +/** +* Bearer definition, new values will be added to the end of the enumeration. +* These are used if KBearerInfo attribute is set or in events if +* KBearerGroupThreshold is set. +*/ +enum TConnMonBearerInfo + { + EBearerInfoUnknown = 0, + EBearerInfoCSD, + EBearerInfoWCDMA, + EBearerInfoLAN, + EBearerInfoCDMA2000, + EBearerInfoGPRS, + EBearerInfoHSCSD, + EBearerInfoEdgeGPRS, + EBearerInfoWLAN, + EBearerInfoBluetooth, + EBearerInfoVirtual, + EBearerInfoVirtualVPN, + EBearerInfoWcdmaCSD, + EBearerInfoHSDPA, + EBearerInfoHSUPA, + EBearerInfoHSxPA + }; + +/** +* Class to contain bearer group information. +*/ +class TConnMonBearerGroupInfo + { +public: + /** + * Constructor. + */ + inline TConnMonBearerGroupInfo(): + iInternal( ETrue ), + iBearerGroups( 0 ), + iBearerGroups2( 0 ) + { + } +public: + /** + * Connection is internal or external. + */ + TBool iInternal; + /** + * Bearer group bitmask. + */ + TUint iBearerGroups; + /** + * Reserved for future use. + */ + TUint iBearerGroups2; + }; + +/** Package class definiton for getting bearer group information. +*/ +typedef TPckgBuf TConnMonBearerGroupInfoBuf; + +/** +* Class to represent a WLAN. Used when reporting WLAN scan results back to a +* client. +*/ +NONSHARABLE_CLASS( CConnMonWlanNetwork ) : public CBase + { +public: + /** Maximum length of a WLAN name (SSID). + */ + static const TUint KMaxNameLength = 32; + /** WLAN BSSID length (mac address). + */ + static const TUint KWlanBssId = 6; + /** Reserved for future use. + */ + static const TUint KExtraCount = 10; + + /** + * Constructor. + * + * @param aName Name (SSID) of the network. + * @param aConnectionMode Mode of the network. + * @param aSignalStrength Signal strength of the network. + * @param aSecurityMode Security mode of the network. + * @param aBssId Mac address (BSSID) of the base station. + * @param aVendorData Not in use. + * @return Pointer to the created CConnMonWlanNetwork object. + */ + IMPORT_C static CConnMonWlanNetwork* NewL( + const TBuf& aName, + TUint aConnectionMode, + TUint aSignalStrength, + TUint aSecurityMode, + const TBuf8& aBssId, + const TDesC& aVendorData ); + + /** + * Constructor. + * + * @return Pointer to the created empty CConnMonWlanNetwork object. + */ + IMPORT_C static CConnMonWlanNetwork* NewL(); + + /** + * Copy constructor. + * + * @param aConnMonWlanNetwork The object which is copied. + * @return Pointer to the created CConnMonWlanNetwork object. + */ + IMPORT_C static CConnMonWlanNetwork* NewL( + CConnMonWlanNetwork& aConnMonWlanNetwork ); + + /** + * Destructor. + */ + IMPORT_C ~CConnMonWlanNetwork(); + + /** + * Assignment operator. + * + * @param aConnMonWlanNetwork The object which is assigned. + */ + IMPORT_C CConnMonWlanNetwork& operator=( + CConnMonWlanNetwork& aConnMonWlanNetwork ); + + /** + * Compares two networks by signal strength. + * + * @param aFirst Reference to first WLAN object. + * @param aSecond Reference to second WLAN object. + * @return Result of the comparison, 1 if first is less than second, 0 if + * they are equal and -1 otherwise. + */ + IMPORT_C static TInt CompareBySignal( + const CConnMonWlanNetwork& aFirst, + const CConnMonWlanNetwork& aSecond ); + + /** + * Obtains the name (SSID) of the network. + * + * @return Name of the wlan network. + */ + inline TBuf Name() + { + return iName; + } + + /** + * Obtains the connection mode of the network. + * + * @return Connection mode (defined in TConnMonNetworkMode). + */ + inline TUint ConnectionMode() + { + return iConnectionMode; + } + + /** + * Obtains the signal strength of the network. + * + * @return Signal strength in dBm. + */ + inline TUint SignalStrength() + { + return iSignalStrength; + } + + /** + * Obtains the security mode of the network. + * + * @return Security mode (defined in TConnMonSecurityMode). + */ + inline TUint SecurityMode() + { + return iSecurityMode; + } + + /** + * Obtains the mac address (BSSID) of the base station. + * + * @return Mac address (BSSID). + */ + inline TBuf8 WlanBssid() + { + return iWlanBssId; + } + + /** + * Obtains a pointer to vendor specific data buffer. + * Ownership of the data is NOT transferred. Not in use, use package + * attribute KWlanProbeRawBuffers instead. + * + * @return Pointer to vendor specific data if available. + */ + inline HBufC* VendorData() + { + return iVendorData; + } + + /** + * Writes object of class CConnMonWlanNetwork to memory. + * Ownership of newly created buffer is transferred to caller. + * + * @return Pointer to heap descriptor. NULL if memory allocation failed. + */ + IMPORT_C const HBufC* ToBuf() const; + + /** + * Reads object of class CConnMonWlanNetwork from memory. + * + * @param aPtrC Pointer to the beginning of the CConnMonWlanNetwork object + * in buffer. + * @param aConnMonWlanNetwork Pointer to CConnMonWlanNetwork object where + * unpacked contents are written. + * @return A Symbian OS error code. + */ + IMPORT_C static TInt FromPtrC( + const TPtrC& aPtrC, + CConnMonWlanNetwork* aConnMonWlanNetwork ); + +private: + /** + * Constructor. + */ + CConnMonWlanNetwork(); + + /** + * Constructor. + * + * @param aName Name (SSID) of the network. + * @param aConnectionMode Mode of the network. + * @param aSignalStrength Signal strength of the network. + * @param aSecurityMode Security mode of the network. + * @param aBssId Mac address (BSSID) of the base station. + * @param aVendorData Not in use. + */ + CConnMonWlanNetwork( + const TBuf& aName, + TUint aConnectionMode, + TUint aSignalStrength, + TUint aSecurityMode, + const TBuf8& aBssId, + const TDesC& aVendorData ); + + /** + * Second-phase constructor. + */ + void ConstructL(); + +private: + TBuf iName; // Network name + TUint iConnectionMode; // WLAN mode, see TConnMonNetworkMode + TUint iSignalStrength; // Signal strength in absolute dBm + TUint iSecurityMode; // See TConnMonSecurityMode + TBuf8 iWlanBssId; // BSSID + HBufC* iVendorData; // For vendor specific data + TUint iExtraBuf[KExtraCount]; // Reserved for future + }; + +/** Class definition for a pointer array of CConnMonWlanNetwork objects. +*/ +typedef RPointerArray RConnMonWlanNetworksPtrArray; + +/** +* Class to contain a package of a pointer array of CConnMonWlanNetwork objects. +*/ +class CConnMonWlanNetworksPtrArrayPckg : public CBase + { +public: + /** + * Constructor. Constructs the package of an array of pointers to + * CConnMonWlanNetwork objects on the heap. + * + * @param aRef Array of pointers to CConnMonWlanNetwork objects. + * @param aBufSize Size of the buffer, intended to contain the package. + */ + CConnMonWlanNetworksPtrArrayPckg( + const RPointerArray& aRef, + TUint aBufSize ); + + /** + * Constructor. Constructs an empty package on the heap. + * + * @param aBufSize Size of the buffer, intended to contain the package. + */ + IMPORT_C CConnMonWlanNetworksPtrArrayPckg( TUint aBufSize ); + + /** + * Destructor. + */ + IMPORT_C virtual ~CConnMonWlanNetworksPtrArrayPckg(); + + /** + * Unpacks the package to a pointer array of CConnMonWlanNetwork objects. + * + * @param aRef Array that will contain the pointers to unpacked objects. + */ + IMPORT_C void UnpackToL( RPointerArray& aRef ) const; + + /** + * Obtains a pointer to the package buffer. + * + * @return Pointer to the package buffer. + */ + IMPORT_C HBufC* Buf() const; + +private: + /** + * Pointer to the package Buffer on the heap. + */ + HBufC* iBuf; + }; + +/** +* Class to represent a WLAN beacon frame. Used when reporting WLAN scan +* results back to a client. +*/ +NONSHARABLE_CLASS( CConnMonWlanProbeRawBuffer ) : public CBase + { + public: + /** + * Constructor. + * + * @param aRawBuffer Beacon frame buffer to be copied to this object. + * @return Pointer to the created CConnMonWlanProbeRawBuffer object. + */ + IMPORT_C static CConnMonWlanProbeRawBuffer* NewL( + const HBufC8* aRawBuffer ); + + /** + * Constructor. + * + * @return Pointer to the created empty CConnMonWlanProbeRawBuffer object. + */ + IMPORT_C static CConnMonWlanProbeRawBuffer* NewL(); + + /** + * Copy constructor. + * + * @param aConnMonWlanProbeRawBuffer The object which is copied. + * @return Pointer to the created CConnMonWlanProbeRawBuffer object. + */ + IMPORT_C static CConnMonWlanProbeRawBuffer* NewL( + CConnMonWlanProbeRawBuffer& aConnMonWlanProbeRawBuffer ); + + /** + * Destructor. + */ + IMPORT_C virtual ~CConnMonWlanProbeRawBuffer(); + + /** + * Assignment operator. + * + * @param aConnMonWlanProbeRawBuffer The object which is assigned. + */ + IMPORT_C CConnMonWlanProbeRawBuffer& operator=( + CConnMonWlanProbeRawBuffer& aConnMonWlanProbeRawBuffer ); + + /** + * Obtains a pointer to the beacon frame buffer. + * + * @return Pointer to the beacon frame buffer. + */ + IMPORT_C HBufC8* RawBuffer() const; + + /** + * Writes object of class CConnMonWlanProbeRawBuffer to memory. + * Ownership of newly created buffer is transferred to caller. + * + * @return Pointer to heap descriptor, NULL if memory allocation failed. + */ + const HBufC8* ToBuf() const; + + /** + * Reads object of class CConnMonWlanProbeRawBuffer from memory. + * + * @param aPtrC Pointer to the beginning of the CConnMonWlanProbeRawBuffer + * object in buffer. + * @param aConnMonWlanProbeRawBuffer Pointer to CConnMonWlanProbeRawBuffer + * object where unpacked contents are written. + * @return A Symbian OS error code. + */ + static TInt FromPtrC( + const TPtrC8& aPtrC, + CConnMonWlanProbeRawBuffer* aConnMonWlanProbeRawBuffer ); + +private: + /** + * Constructor. + */ + CConnMonWlanProbeRawBuffer(); + + /** + * Second-phase constructor. + */ + void ConstructL(); + + /** + * Second-phase constructor. + * + * @param aRawBuffer Buffer to be copied to this object. + */ + void ConstructL( const HBufC8* aRawBuffer ); + +private: + HBufC8* iRawBuffer; // Beacon frame buffer + }; + +/** Class definition for a pointer array of CConnMonWlanProbeRawBuffer objects. +*/ +typedef RPointerArray RConnMonWlanProbeRawBuffersPtrArray; + +/** +* Class to contain a package of a pointer array of CConnMonWlanProbeRawBuffer +* objects. +*/ +class CConnMonWlanProbeRawBuffersPckg : public CBase + { +public: + /** + * Constructor. Constructs the package of an array of pointers to + * CConnMonWlanProbeRawBuffer objects on the heap. + * + * @param aRef Array of pointers to CConnMonWlanProbeRawBuffer objects. + * @param aBufSize Size of the buffer, intended to contain the package. + */ + CConnMonWlanProbeRawBuffersPckg( + const RConnMonWlanProbeRawBuffersPtrArray& aRef, + TUint aBufSize ); + + /** + * Constructor. Constructs an empty package on the heap. + * + * @param aBufSize Size of the buffer, intended to contain the package. + */ + IMPORT_C CConnMonWlanProbeRawBuffersPckg( TUint aBufSize ); + + /** + * Destructor. + */ + IMPORT_C virtual ~CConnMonWlanProbeRawBuffersPckg(); + + /** + * Unpacks the package to a pointer array of CConnMonWlanProbeRawBuffer + * objects. + * + * @param aRef Array that will contain the pointers to unpacked objects. + */ + IMPORT_C void UnpackToL( RConnMonWlanProbeRawBuffersPtrArray& aRef ) const; + + /** + * Obtains a pointer to the package buffer. + * + * @return Pointer to the package buffer. + */ + IMPORT_C HBufC8* Buf() const; + + /** + * Obtains the total number of found WLANs. + * + * @return Total count (iBuf[0]). + */ + IMPORT_C TUint Total() const; + + /** + * Obtains the number of trasferred WLANs. This will be less than total + * count if there was not enough memory in buffer to include all found + * WLANs. + * + * @return Transfered count in buffer (iBuf[1]). + */ + IMPORT_C TUint Count() const; + +private: + /** + * Pointer to the package buffer on the heap. + */ + HBufC8* iBuf; + }; + +/** +* Interface template for the class T serialization to/from HBuf/TPtr. +* Class T could be any type of class (T, C, etc.). +*/ +template + class MDesSerializer + { +public: + /** + * Have to pack the object of class T to HBufC. + * Ownership of newly created pointer is transferred to caller. + * + * @return Pointer to the heap descriptor. + */ + virtual const HBufC* ToBuf() const = 0; + + /** + * Have to unpack object of class T from aPtrC. + * + * @return Constant pointer to the heap descriptor. + */ + static T FromPtrC( const TPtrC& aPtrC ); + }; + +/** +* Class representing an ID number. +* MDesSerializer - abstract interface for class serialization. +*/ +class TConnMonId : public MDesSerializer + { +public: + /** + * Defines the maximum size of the object in TChar's. + * +1 is for rounding to bigger integer. + */ + static const TUint KMaxSize = ( sizeof( TUint ) ) / sizeof( TChar ) + 1; + + /** + * Defines shifts of fields inside the object. + */ + enum FieldsShifts + { + EId = 0 + }; + + /** + * Constructor. + * + * @param aId ID number. + */ + IMPORT_C TConnMonId( TUint aId ); + + /** + * Obtains the ID number. + * + * @return ID number. + */ + IMPORT_C TUint Id() const; + + // From MDesSerializer + + /** + * Writes object of class TConnMonId to memory. + * Ownership of newly created buffer is transferred to caller. + * + * @return Pointer to heap descriptor, NULL if memory allocation failed. + */ + IMPORT_C const HBufC* ToBuf() const; + + /** + * Reads object of class TConnMonId from memory. + * + * @param aPtrC Pointer to the beginning of the TConnMonId object in buffer. + * @return The newly created TConnMonId object. + */ + IMPORT_C static TConnMonId FromPtrC( const TPtrC& aPtrC ); + +protected: + /** + * ID number. + */ + const TUint iId; + }; + +/** Class definition for an array of TConnMonId objects. +*/ +typedef RArray RConnMonIdsArray; + +/** +* Class to contain a package of an array of TConnMonId objects. +*/ +class ConnMonIdsArrayPckg + { +public: + /** + * Constructor. Constructs the package of an array of TConnMonId objects + * on the heap. + * + * @param aRef Array of TConnMonId objects. + * @param aBufSize Size of the buffer, intended to contain the package. + */ + ConnMonIdsArrayPckg( const RArray& aRef, TUint aBufSize ); + + /** + * Constructor. Constructs an empty package on the heap. + * + * @param aBufSize Size of the buffer, intended to contain the package. + */ + IMPORT_C ConnMonIdsArrayPckg( TUint aBufSize ); + + /** + * Destructor. + */ + IMPORT_C virtual ~ConnMonIdsArrayPckg(); + + /** + * Unpacks the package to an array of TConnMonId objects. + * + * @param aRef Array that will contain the unpacked objects. + */ + IMPORT_C void UnpackToL( RArray& aRef ) const; + + /** + * Obtains a pointer to the package buffer. + * + * @return Pointer to the package buffer. + */ + IMPORT_C HBufC* Buf() const; + +protected: + /** + * Pointer to the package buffer on the heap. + */ + HBufC* iBuf; + }; + +// Forward declarations +class CConnMonEventBase; +class CConnMonEventHandler; + +/** +* Client application must implement the MConnectionMonitorObserver interface in +* order to receive notifications. MConnectionMonitorObserver::EventL() method +* will be called every time an event arrives. +* +* @lib CONNMON.LIB +*/ +class MConnectionMonitorObserver + { +public: + /** + * This method is called every time an event occurs. + * + * @param aConnMonEvent The event information. + */ + virtual void EventL( const CConnMonEventBase &aConnMonEvent ) = 0; + }; + +/** +* RConnectionMonitor +* +* @lib CONNMON.LIB +*/ +class RConnectionMonitor : public RSessionBase + { +public: + /** + * Constructor. + */ + inline RConnectionMonitor(): + RSessionBase(), + iHandler( 0 ), + iPtrArray(), + iIndex( 0 ) + { + } + +public: + /** + * Connects the client to the Connection Monitor Server. It must be called + * before any of other methods during the Connection Monitor session. + * + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt ConnectL(); + + /** + * Closes the Connection Monitor session. An opened RConnectionMonitor must + * be closed explicitily to prevent a resource (memory) leak. + */ + IMPORT_C void Close(); + + /** + * Gathers information on currently active connections. + * + * @param aConnectionCount On completion, contains the number of active + * connections. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetConnectionCount( + TUint& aConnectionCount, + TRequestStatus& aStatus ); + + /** + * Gets the connection ID and the count of the subconnections for the given + * index. GetConnectionCount() must be called to gather the information on + * active connections before calling this method. + * + * @param aIndex Must be between 1 and the count returned by + * GetConnectionCount(). + * @param aConnectionId On return, contains the connection ID. + * @param aSubConnectionCount On return, contains the number of + * subconnections. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt GetConnectionInfo( + const TUint aIndex, + TUint& aConnectionId, + TUint& aSubConnectionCount ) const; + + /** + * Gets the subconnection ID for the given index. + * + * @param aConnectionId Connection ID. + * @param aIndex Must be between 1 and the subconnection count returned by + * GetConnectionInfo(). + * @param aSubConnectionId On return, contains the subconnection ID. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt GetSubConnectionInfo( + const TUint aConnectionId, + const TUint aIndex, + TUint& aSubConnectionId ) const; + + /** + * Gets the value for a TInt attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested TInt attribute. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetIntAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TInt& aValue, + TRequestStatus& aStatus ); + + /** + * Gets the value for a TUint attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested TUint attribute. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetUintAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TUint& aValue, + TRequestStatus& aStatus ); + + /** + * Gets the value for a TBool attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested TBool attribute. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetBoolAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TBool& aValue, + TRequestStatus& aStatus ); + + /** + * Gets the value for a string attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested string. Use a 16-bit + * descriptor! + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetStringAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TDes& aValue, + TRequestStatus& aStatus ) const; + + /** + * Gets the value for a packaged attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested packaged attribute. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetPckgAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TDes8& aValue, + TRequestStatus& aStatus ) const; + + /** + * Gets the value for a packaged attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be retrieved. + * @param aValue On completion, contains the requested packaged attribute. + * @param aStatus KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C void GetPckgAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + TDes16& aValue, + TRequestStatus& aStatus ) const; + + /** + * Sets the value for a TInt attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be set. + * @param aValue The value to be set. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt SetIntAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + const TInt aValue ) const; + + /** + * Sets the value for a TUint attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be set. + * @param aValue The value to be set. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt SetUintAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + const TUint aValue ) const; + + /** + * Sets the value for a TBool attribute. + * + * This method can be used to stop a connection (KConnectionStop). + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be set. + * @param aValue The value to be set. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt SetBoolAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + const TBool aValue ) const; + + /** + * Sets the value for a string attribute. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be set. + * @param aValue The string value to be set. Must be a 16-bit descriptor. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt SetStringAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + const TDes& aValue ) const; + + /** + * Sets the value for a packaged attribute. There is currently no packaged + * attributes that can be set. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. If set to 0, method applies to + * connection. + * @param aAttribute Identifies the attribute to be set. + * @param aValue The value to be set. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt SetPckgAttribute( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aAttribute, + const TDes8& aValue ) const; + + /** + * Cancels an asyncronous request. If there is several active requests of + * the same type (for example GetIntAttribute), they will all be cancelled. + * When a request is cancelled, it is completed with error code KErrCancel. + * + * @param aReqToCancel Identifies the request type to be cancelled. + * The different types are defined in TConnMonAsyncRequest. + */ + IMPORT_C void CancelAsyncRequest( TInt aReqToCancel ); + + /** + * Registers an event observer to catch connection monitor events. + * + * @param aObserver The event observer. + * @return KErrNone if successful, a system-wide error code if not. + */ + IMPORT_C TInt NotifyEventL( MConnectionMonitorObserver& aObserver ); + + /** + * Cancels the notifications from connection monitor. + */ + IMPORT_C void CancelNotifications(); + +private: + void ReceiveEvent( + TDes8& aBuffer, + TDes8& aExtraBuf, + TRequestStatus& aStatus ); + void CancelReceiveEvent(); + TBool IsConnected() const; + TPtr8& NextPtr(); + +private: + CConnMonEventHandler* iHandler; + RArray iPtrArray; + TInt iIndex; + +private: + friend class CConnMonEventHandler; + }; + +/** +* Base class for all ConnMon event types. +* +* Example how to convert an event according to type. +* @code +* void CMyConnMonObserver::EventL( const CConnMonEventBase& aEvent ) +* { +* switch( aEvent.EventType() ) +* { +* case EConnMonCreateConnection: +* CConnMonCreateConnection* realEvent; +* realEvent = (CConnMonCreateConnection*) &aEvent; +* //... +* @endcode +*/ +NONSHARABLE_CLASS( CConnMonEventBase ) : public CBase + { +public: + /** + * Constructor. + * + * @param aEventType Event type. + * @param iConnectionId Connection ID. + */ + CConnMonEventBase( const TInt aEventType, const TUint iConnectionId ); + + /** + * Destructor. + */ + ~CConnMonEventBase(); + +public: + /** + * Gets the type of the event. + * + * @return Type of the event. Values are defined in TConnMonEventType. + */ + IMPORT_C TInt EventType() const; + + /** + * Gets the connection ID of the connection. + * + * @return Connection ID. + */ + IMPORT_C TUint ConnectionId() const; + +private: + TInt iEventType; + TUint iConnectionId; + }; + +/** +* This event is triggered when a new connection has been created. The +* connection ID passed in the event is a new ID number that ConnMon assigned to +* the new connection. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonCreateConnection ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + */ + CConnMonCreateConnection( const TUint aConnectionId ); + + /** + * Destructor. + */ + ~CConnMonCreateConnection(); + }; + +/** +* This event is triggered when a connection has been deleted. The connection ID +* passed in the event is the connection ID of the deleted connection. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonDeleteConnection ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aDownlinkData Downlink data volume. + * @param aUplinkData Uplink data volume. + * @param aAuthDelete Was connection stopped in an authoritative way. + */ + CConnMonDeleteConnection( + const TUint aConnectionId, + const TUint aDownlinkData, + const TUint aUplinkData, + const TBool aAuthDelete ); + + /** + * Destructor. + */ + ~CConnMonDeleteConnection(); + +public: + /** + * Gets the downlink data volume. + * + * @return Downlink data volume in bytes. + */ + IMPORT_C TUint DownlinkData() const; + + /** + * Gets the uplink data volume. + * + * @return Uplink data volume in bytes. + */ + IMPORT_C TUint UplinkData() const; + + /** + * Checks if the connection was stopped in an authoritative way. + * ETrue will be returned if the user has deactivated the connection by + * using Connection Monitor or if some application has issued + * RConnection::Stop( RConnection::EStopAuthoritative ). + * + * @return ETrue if connection has been deactivated in an authoritative + * way, otherwise returns EFalse. + */ + IMPORT_C TBool AuthoritativeDelete() const; + +private: + TUint iDownlinkData; + TUint iUplinkData; + TBool iAuthDelete; + }; + +/** +* This event is triggered when a new subconnection has been created. +* Subconnections are not supported currently. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonCreateSubConnection ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + */ + CConnMonCreateSubConnection( + const TUint aConnectionId, + const TUint aSubConnectionId ); + + /** + * Destructor. + */ + ~CConnMonCreateSubConnection(); + +public: + /** + * Gets the new subconnection ID. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + +private: + TUint iSubConnectionId; + }; + +/** +* This event is triggered when a subconnection has been deleted. +* Subconnections are not supported currently. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonDeleteSubConnection ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + * @param aDownlinkData Downlink data volume. + * @param aUplinkData Uplink data volume. + * @param aAuthDelete Was connection stopped in an authoritative way. + */ + CConnMonDeleteSubConnection( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aDownlinkData, + const TUint aUplinkData, + const TBool aAuthDelete ); + + /** + * Destructor. + */ + ~CConnMonDeleteSubConnection(); + +public: + /** + * Gets the subconnection ID of the deleted subconnection. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + + /** + * Gets the downlink data volume. + * + * @return Downlink data volume in bytes. + */ + IMPORT_C TUint DownlinkData() const; + + /** + * Gets the uplink data volume. + * + * @return Uplink data volume in bytes. + */ + IMPORT_C TUint UplinkData() const; + + /** + * Checks if the connection was stopped in an authoritative way. + * ETrue will be returned if the user has deactivated the connection by + * using Connection Monitor or if some application has issued + * RConnection::Stop( RConnection::EStopAuthoritative ). + * + * @return ETrue if connection has been deactivated in an authoritative + * way, otherwise returns EFalse. + */ + IMPORT_C TBool AuthoritativeDelete() const; + +private: + TUint iSubConnectionId; + TUint iDownlinkData; + TUint iUplinkData; + TBool iAuthDelete; + }; + +/** +* This event is triggered when there is a sufficient change in the volume of +* downlink data for a specific connection. The event is sent each time a client +* specified amount (KDownlinkDataThreshold) of new data has been sent. If +* another ConnMon client has requested for these events for the same +* connection, the smallest threshold value will be used globally. If +* KDownlinkDataThreshold is 0 (default), events will not be sent for that +* connection. To prevent rapid flooding of these events, different bearers have +* appropriate minimum threshold values which will be used to override too small +* thresholds when necessary. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonDownlinkDataThreshold ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + * @param aDownlinkData Downlink data volume. + */ + CConnMonDownlinkDataThreshold( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aDownlinkData ); + + /** + * Destructor. + */ + ~CConnMonDownlinkDataThreshold(); + +public: + /** + * Gets the subconnection ID. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + + /** + * Gets the downlink data volume. + * + * @return Downlink data volume in bytes. + */ + IMPORT_C TUint DownlinkData() const; + +private: + TUint iSubConnectionId; + TUint iDownlinkData; + }; + +/** +* This event is triggered when there is a sufficient change in the volume of +* uplink data for a specific connection. The event is sent each time a client +* specified amount (KUplinkDataThreshold) of new data has been received. If +* another ConnMon client has requested for these events for the same +* connection, the smallest threshold value will be used globally. If +* KUplinkDataThreshold is 0 (default), events will not be sent for that +* connection. To prevent rapid flooding of these events, different bearers have +* appropriate minimum threshold values which will be used to override too small +* thresholds when necessary. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonUplinkDataThreshold ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + * @param aUplinkData Uplink data volume. + */ + CConnMonUplinkDataThreshold( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TUint aUplinkData ); + + /** + * Destructor. + */ + ~CConnMonUplinkDataThreshold(); + +public: + /** + * Gets the subconnection ID. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + + /** + * Gets the uplink data volume. + * + * @return Uplink data volume in bytes. + */ + IMPORT_C TUint UplinkData() const; + +private: + TUint iSubConnectionId; + TUint iUplinkData; + }; + +/** +* This event is triggered when network status changes for some packet data +* connection. The connection ID passed in the event is a bearer specific +* connection ID (see TConnMonBearerId). The same information can be retrieved +* with TInt attribute KNetworkStatus. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonNetworkStatusChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aNetworkStatus Network status. + */ + CConnMonNetworkStatusChange( + const TUint aConnectionId, + const TInt aNetworkStatus ); + + /** + * Destructor. + */ + ~CConnMonNetworkStatusChange(); + +public: + /** + * Gets the network status. + * + * @return Network status. Values are defined in TConnMonNetworkStatus. + */ + IMPORT_C TInt NetworkStatus() const; + +private: + TInt iNetworkStatus; + }; + +/** +* This event is triggered when the status of some connection changes. +* The same information can be retrieved with TInt attribute KConnectionStatus. +* Connection status values are defined in nifvar.h. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonConnectionStatusChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + * @param aConnectionStatus Connection status. + */ + CConnMonConnectionStatusChange( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TInt aConnectionStatus ); + + /** + * Destructor. + */ + ~CConnMonConnectionStatusChange(); + +public: + /** + * Gets the subconnection ID. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + + /** + * Gets the connection status. + * + * @return Connection status. Values are defined in nifvar.h. + */ + IMPORT_C TInt ConnectionStatus() const; + +private: + TUint iSubConnectionId; + TInt iConnectionStatus; + }; + +/** +* This event is triggered when some connection changes from active to idle or +* vice versa. The client must set KActivityTimeThreshold to receive these +* events. KActivityTimeThreshold defines the period (in seconds) for checking +* wether the connection is active or not. The minimum allowed value is 5 +* seconds. The connection is considered active, if data has been passed during +* the last period, otherwise it is considered inactive. The same information +* can be retrieved with TBool attribute KConnectionActive. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonConnectionActivityChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSubConnectionId Subconnection ID. + * @param aActivity Connection activity. + */ + CConnMonConnectionActivityChange( + const TUint aConnectionId, + const TUint aSubConnectionId, + const TBool aActivity ); + + /** + * Destructor. + */ + ~CConnMonConnectionActivityChange(); + +public: + /** + * Gets the subconnection ID. + * + * @return Subconnection ID. + */ + IMPORT_C TUint SubConnectionId() const; + + /** + * Gets the connection activity. + * + * @return ETrue if the connection is active, EFalse if not. + */ + IMPORT_C TBool ConnectionActivity() const; + +private: + TUint iSubConnectionId; + TBool iActivity; + }; + +/** +* This event is triggered when network registration status (GSM/GPRS/WCDMA) +* changes. The connection ID passed in the event is a bearer specific +* connection ID (see TConnMonBearerId). The same information can be retrieved +* with TInt attribute KNetworkRegistration. Network registration values are +* defined in TConnMonNetworkRegistration. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonNetworkRegistrationChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aRegistrationStatus Network registration status. + */ + CConnMonNetworkRegistrationChange( + const TUint aConnectionId, + const TInt aRegistrationStatus ); + + /** + * Destructor. + */ + ~CConnMonNetworkRegistrationChange(); + +public: + /** + * Gets the network registration status. + * + * @return Registration status. Values are defined in + * TConnMonNetworkRegistration. + */ + IMPORT_C TInt RegistrationStatus() const; + +private: + TInt iRegistrationStatus; + }; + +/** +* This event is triggered when bearer type (GPRS/EdgeGPRS/WCDMA) changes. The +* connection ID passed in the event is a bearer specific connection ID, either +* EBearerIdGPRS or EBearerIdWCDMA (see TConnMonBearerId). The new bearer passed +* in the event can be EBearerGPRS, EBearerEdgeGPRS or EBearerWCDMA (see +* TConnMonBearerType). The same information can be retrieved with TInt +* attribute KBearer. +* +* Note: If TUint attribute KBearerGroupThreshold is set, these events are +* disabled and events EConnMonBearerInfoChange and EConnMonBearerGroupChange +* are used instead. Use these events, for example, if HSDPA related information +* is required. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonBearerChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aBearer Bearer. + */ + CConnMonBearerChange( const TUint aConnectionId, const TInt aBearer ); + + /** + * Destructor. + */ + ~CConnMonBearerChange(); + +public: + /** + * Gets the new bearer. + * + * @return New bearer. Values are defined in TConnMonBearerType. + */ + IMPORT_C TInt Bearer() const; + +private: + TInt iBearer; + }; + +/** +* This event is triggered when signal strength changes. The connection ID +* passed in the event is a bearer specific connection ID (see +* TConnMonBearerId). This event is valid only for cellular (GPRS, WCDMA, etc.) +* bearers and not for other bearers, e.g. WLAN. The client must set +* KSignalStrengthThreshold to 1 to receive these events. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonSignalStrengthChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSignalStrength Signal strength in dBm. + */ + CConnMonSignalStrengthChange( + const TUint aConnectionId, + const TInt aSignalStrength ); + + /** + * Destructor. + */ + ~CConnMonSignalStrengthChange(); + +public: + /** + * Gets the signal strength. + * + * @return Signal strength in dBm. + */ + IMPORT_C TInt SignalStrength() const; + +private: + TInt iSignalStrength; + }; + +/** +* This event is triggered when the availability of some bearer changes. The +* connection ID passed in the event is a bearer specific connection ID (see +* TConnMonBearerId). The client must set KBearerAvailabilityThreshold to 1 to +* receive these events. Using this event for detecting changes in WLAN +* availability requires WLAN background scanning to be enabled. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonBearerAvailabilityChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aAvailability Availability of the bearer. + */ + CConnMonBearerAvailabilityChange( + const TUint aConnectionId, + const TBool aAvailability ); + + /** + * Destructor. + */ + ~CConnMonBearerAvailabilityChange(); + +public: + /** + * Gets the availability of the bearer. + * + * @return ETrue if the bearer is available, EFalse if not. + */ + IMPORT_C TBool Availability() const; + +private: + TBool iAvailability; + }; + +/** +* This event is triggered when a plug-in sends a bearer specific event that is +* unknown to ConnMon. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonGenericEvent ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aType Event type. + * @param aConnectionId Connection ID. + * @param aData Pointer to the event data. + */ + CConnMonGenericEvent( + const TUint aType, + const TUint aConnectionId, + TAny* aData ); + + /** + * Destructor. + */ + ~CConnMonGenericEvent(); + +public: + /** + * Gets a pointer to the event data. + * The pointer is valid only inside EventL(). + * + * @return Pointer to the event data. + */ + IMPORT_C TAny* Data() const; + +private: + TAny* iData; + }; + +/** +* This event is triggered when IAP availability changes. The connection ID +* passed in the event is the generic connection ID EBearerIdAll. The ID numbers +* of available IAPs are included in the event (see TConnMonIapInfo). The same +* information can be retrieved with packaged attribute KIapAvailability. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonIapAvailabilityChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aIapInfoPtr Pointer to the IAP availability information. + */ + CConnMonIapAvailabilityChange( + const TUint aConnectionId, + const TConnMonIapInfo* aIapInfoPtr ); + + /** + * Destructor. + */ + ~CConnMonIapAvailabilityChange(); + +public: + /** + * Gets the IAP availability information. + * + * @return IAP availability information. + */ + IMPORT_C TConnMonIapInfo IapAvailability() const; + +private: + TConnMonIapInfo iIapInfo; + }; + +/** +* This event is triggered when the used WLAN transmit power changes. The +* connection ID passed in the event is the bearer specific connection ID +* EBearerIdWLAN. Transmit power is given in milliwatts (mW). The same +* information can be retrieved with TUint attribute KTransmitPower. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonTransmitPowerChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aTransmitPower Transmit power in mW. + */ + CConnMonTransmitPowerChange( + const TUint aConnectionId, + const TUint aTransmitPower ); + + /** + * Destructor. + */ + ~CConnMonTransmitPowerChange(); + +public: + /** + * Gets the transmit power. + * + * @return Transmit power in mW. + */ + IMPORT_C TUint TransmitPower() const; + +private: + TUint iTransmitPower; + }; + +/** +* This event is triggered when SNAP availability changes. The connection ID +* passed in the event is the generic connection ID EBearerIdAll. The ID numbers +* of available SNAPs are included in the event (see TConnMonSNAPInfo). The same +* information can be retrieved with packaged attributes KSNAPsAvailability and +* KAvailableSNAPsIds. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonSNAPsAvailabilityChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aSNAPsAvailable Number of available SNAPs. + * @param aSNAPInfoPtr Pointer to the SNAP availability information. + */ + CConnMonSNAPsAvailabilityChange( + const TUint aConnectionId, + const TUint aSNAPsAvailable, + const TConnMonSNAPInfo* aSNAPInfoPtr ); + + /** + * Destructor. + */ + ~CConnMonSNAPsAvailabilityChange(); + +public: + /** + * Gets the SNAP availability information. + * + * @return SNAP availability information. + */ + IMPORT_C TConnMonSNAPInfo SNAPAvailability() const; + + /** + * Gets the number of available SNAPs. + * + * @return Number of available SNAPs. + */ + IMPORT_C TUint SNAPsAvailabile() const; + +private: + TConnMonSNAPInfo iSNAPInfo; + TUint iSNAPsAvailable; + }; + +/** +* This event is triggered when new WLAN networks are detected during a WLAN +* scan. The connection ID passed in the event is the bearer specific connection +* ID EBearerIdWLAN. To receive these events, WLAN background scanning must be +* enabled, or some other mechanism must be used to trigger the necessary WLAN +* scans. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonNewWLANNetworkDetected ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + */ + CConnMonNewWLANNetworkDetected( const TUint aConnectionId ); + + /** + * Destructor. + */ + ~CConnMonNewWLANNetworkDetected(); + }; + +/** +* This event is triggered when one or more WLAN networks have been lost since +* the last WLAN scan. The connection ID passed in the event is the bearer +* specific connection ID EBearerIdWLAN. To receive these events, WLAN +* background scanning must be enabled, or some other mechanism must be used to +* trigger the necessary WLAN scans. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonOldWLANNetworkLost ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + */ + CConnMonOldWLANNetworkLost( const TUint aConnectionId ); + + /** + * Destructor. + */ + ~CConnMonOldWLANNetworkLost(); + }; + +/** +* This event is triggered when GPRS or WCDMA bearer availability changes, a +* phone call is started, or a phone call ends. The connection ID passed in the +* event is a bearer specific connection ID, either EBearerIdGPRS or +* EBearerIdWCDMA (see TConnMonBearerId). +* +* EConnMonPacketDataUnavailable and EConnMonPacketDataAvailable events form a +* pair. Two events are always sent, one with connection ID EBearerIdGPRS for 2G +* network, and one with connection ID EBearerIdWCDMA for 3G network. The event +* for the network that the phone is not registered to is always of type +* EConnMonPacketDataUnavailable. If the phone does not support dual transfer +* mode and a call is started, a GPRS or WCDMA packet data connection will be +* put on hold. In this scenario, both will be of type +* EConnMonPacketDataUnavailable. The same information can be retrieved with +* TBool attribute KPacketDataAvailability. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonPacketDataUnavailable ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Bearer specific connection ID, EBearerIdGPRS or + * EBearerIdWCDMA. + */ + CConnMonPacketDataUnavailable( const TUint aConnectionId ); + + /** + * Destructor. + */ + virtual ~CConnMonPacketDataUnavailable(); + }; + +/** +* This event is triggered when GPRS or WCDMA bearer availability changes, a +* phone call is started, or a phone call ends. The connection ID passed in the +* event is a bearer specific connection ID, either EBearerIdGPRS or +* EBearerIdWCDMA (see TConnMonBearerId). +* +* EConnMonPacketDataAvailable and EConnMonPacketDataUnavailable events form a +* pair. Two events are always sent, one with connection ID EBearerIdGPRS for 2G +* network, and one with connection ID EBearerIdWCDMA for 3G network. The event +* for the network that the phone is not registered to is always of type +* EConnMonPacketDataUnavailable. If the phone does not support dual transfer +* mode and a call is started, a GPRS or WCDMA packet data connection will be +* put on hold. In this scenario, both will be of type +* EConnMonPacketDataUnavailable. The same information can be retrieved with +* TBool attribute KPacketDataAvailability. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonPacketDataAvailable ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Bearer specific connection ID, EBearerIdGPRS or + * EBearerIdWCDMA. + */ + CConnMonPacketDataAvailable( const TUint aConnectionId ); + + /** + * Destructor. + */ + virtual ~CConnMonPacketDataAvailable(); + }; + +/** +* This event is triggered when there is a change in bearer information for an +* existing connection, or if the network mode changes e.g. from 2G to 3G. For +* connection specific events, the connection ID passed in the event is the +* respective connection specific ID, and for network level events, the +* connection ID is EBearerIdAll. The same connection level information can be +* retrieved with TInt attribute KBearerInfo. The bearer info values are defined +* in TConnMonBearerInfo. +* +* Note: The client needs to set the TUint attribute KBearerGroupThreshold in +* order to receive these events. This also disables EConnMonBearerChange events. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonBearerInfoChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aBearerInfo Bearer information. + */ + CConnMonBearerInfoChange( + const TUint aConnectionId, + const TInt aBearerInfo ); + + /** + * Destructor. + */ + ~CConnMonBearerInfoChange(); + +public: + /** + * Gets the new bearer information. Values are defined in TConnMonBearerInfo. + * + * @return New bearer information. + */ + IMPORT_C TInt BearerInfo() const; + +private: + TInt iBearerInfo; + }; + +/** +* This event is triggered when there is a change in bearer group information +* for an existing connection. The connection ID passed in the event is the +* respective connection specific ID. The same information can be retrieved with +* packaged attribute KBearerGroupInfo. The bearer group bitmask is defined in +* TConnMonBearerGroup. +* +* Note: The client needs to set the TUint attribute KBearerGroupThreshold in +* order to receive these events. This also disables EConnMonBearerChange events. +* +* @lib CONNMON.LIB +*/ +NONSHARABLE_CLASS( CConnMonBearerGroupChange ) : public CConnMonEventBase + { +public: + /** + * Constructor. + * + * @param aConnectionId Connection ID. + * @param aBearerGroups1 First bearer group bitmask. + * @param aBearerGroups2 Second bearer group bitmask. + * @param aInternal ETrue if connection is internal, EFalse if external. + */ + CConnMonBearerGroupChange( + const TUint aConnectionId, + const TUint aBearerGroups1, + const TUint aBearerGroups2, + const TBool aInternal ); + + /** + * Destructor. + */ + ~CConnMonBearerGroupChange(); + +public: + /** + * Gets the new bearer groups. Values are defined in TConnMonBearerGroup. + * + * @param aBearerGroups1 Will contain the first bearer group bitmask. + * @param aBearerGroups2 Will contain the second bearer group bitmask. + */ + IMPORT_C void BearerGroups( + TUint& aBearerGroups1, + TUint& aBearerGroups2 ) const; + + /** + * Gets the information whether the current connection bearer is internal + * or external. + * + * @return ETrue if the bearer is internal and EFalse if external. + */ + IMPORT_C TBool Internal() const; + +private: + TBool iInternal; // ETrue for internal, EFalse for external connection. + TUint iBearerGroups1; // Contains the groups as bitmask. + TUint iBearerGroups2; // Reserved for the future use. + }; + +#endif // __CONNECTIONMONITOR_H + +// End of file