1 apaccesspointitem.h |
1 /* |
|
2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * 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 |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Declaration of the class CApAccessPointItem |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #ifndef ACCESSPOINTITEM_H |
|
20 #define ACCESSPOINTITEM_H |
|
21 |
|
22 // Deprecation warning |
|
23 #warning This header file has been deprecated. Will be removed in one of the next SDK releases. |
|
24 |
|
25 |
|
26 // INCLUDES |
|
27 #include <etelmm.h> |
|
28 #include <cdbcols.h> |
|
29 #include <nifvar.h> |
|
30 #include <ApEngineVer.h> |
|
31 #include <ApEngineConsts.h> |
|
32 |
|
33 |
|
34 // DATA TYPES |
|
35 /** |
|
36 * This enum is used to identify the data when reading or writing |
|
37 * CApAccessPointItem data. |
|
38 * <br>Field types: |
|
39 * <br> |
|
40 * 8 - bit text: |
|
41 * <br>ReadTextL( const TApMember aColumn, TDes8& aValue ) |
|
42 * <br>WriteTextL( const TApMember aColumn, const TDesC8& aValue ) |
|
43 * <br> EApIspIfCallbackInfo |
|
44 * <br> EApIspInitString |
|
45 * <br> |
|
46 * <br> |
|
47 * 16-bit text: |
|
48 * <br>ReadTextL( const TApMember aColumn, TDes16& aValue ) |
|
49 * <br>WriteTextL( const TApMember aColumn, const TDesC16& aValue ) |
|
50 * <br> EApWapAccessPointName |
|
51 * <br> EApWapCurrentBearer |
|
52 * <br> EApWapGatewayAddress |
|
53 * <br> EApWapServiceCentreAddress |
|
54 * <br> EApIapName |
|
55 * <br> EApIapServiceType |
|
56 * <br> EApIspName |
|
57 * <br> EApIspDescription |
|
58 * <br> EApIspDefaultTelNumber |
|
59 * <br> EApIspLoginName |
|
60 * <br> EApIspLoginPass |
|
61 * <br> EApIspIfName |
|
62 * <br> EApGprsIfName |
|
63 * <br> EApIspIfParams |
|
64 * <br> EApGprsIfParams |
|
65 * <br> EApIspIfNetworks |
|
66 * <br> EApGprsIfNetworks |
|
67 * <br> EApIspIfAuthName |
|
68 * <br> EApGprsIfAuthName |
|
69 * <br> EApIspIfAuthPass |
|
70 * <br> EApGprsIfAuthPassword |
|
71 * <br> EApIspIPAddr |
|
72 * <br> EApGprsIpAddr |
|
73 * <br> EApIspIPNetMask |
|
74 * <br> EApGprsIpNetMask |
|
75 * <br> EApIspIPGateway |
|
76 * <br> EApGprsIpGateway |
|
77 * <br> EApIspIPNameServer1 |
|
78 * <br> EApGprsIPNameServer1 |
|
79 * <br> EApIspIPNameServer2 |
|
80 * <br> EApGprsIPNameServer2 |
|
81 * <br> EApGprsPdpAddress |
|
82 * <br> EApProxyProtocolName |
|
83 * <br> EApNetworkName |
|
84 * <br> EApProxyLoginName |
|
85 * <br> EApProxyLoginPass |
|
86 * <br> EApIP6NameServer1 |
|
87 * <br> EApIP6NameServer2 |
|
88 * <br> EApLanBearerName |
|
89 * <br> |
|
90 * <br>Long text, 16 bit: |
|
91 * <br>const HBufC* ReadConstLongTextL( const TApMember aColumn ) |
|
92 * <br>WriteLongTextL( const TApMember aColumn, const TDesC& aValue ) |
|
93 * <br> EApWapStartPage |
|
94 * <br> EApIspLoginScript |
|
95 * <br> EApGprsAccessPointName |
|
96 * <br> EApProxyServerAddress |
|
97 * <br> EApProxyExceptions |
|
98 * <br> |
|
99 * <br>Uint: |
|
100 * <br>ReadUint( const TApMember aColumn, TUint32& aValue ) |
|
101 * <br>WriteUint( const TApMember aColumn, const TUint32& aValue ) |
|
102 * <br> EApWapAccessPointID |
|
103 |
|
104 // DEPRECATED |
|
105 * <br> EApWapIsp |
|
106 |
|
107 // DEPRECATED |
|
108 * <br> EApWapChargecard |
|
109 |
|
110 * <br> EApWapIap |
|
111 |
|
112 // DEPRECATED |
|
113 * <br> EApWapIspType |
|
114 |
|
115 * <br> EApIapServiceId |
|
116 * <br> EApIapChargecard |
|
117 * <br> EApIspIspType |
|
118 * <br> EApIspAuthRetries |
|
119 * <br> EApGprsIfAuthRetries |
|
120 * <br> EApIspIfCallbackType |
|
121 * <br> EApIspCallBackTimeOut |
|
122 * <br> EApIspBearerName |
|
123 * <br> EApIspBearerSpeed |
|
124 * <br> EApIspBearerCE |
|
125 * <br> EApIspBearerType |
|
126 * <br> EApIspBearerCallTypeIsdn |
|
127 * <br> EApIspChannelCoding |
|
128 * <br> EApIspAIUR |
|
129 * <br> EApIspRequestedTimeSlots |
|
130 * <br> EApIspMaximumTimeSlots |
|
131 * <br> EApGprsPdpType |
|
132 * <br> EApGprsReqPrecedence |
|
133 * <br> EApGprsReqDelay |
|
134 * <br> EApGprsReqReliability |
|
135 * <br> EApGprsReqPeakThroughput |
|
136 * <br> EApGprsReqMeanPeakThroughput |
|
137 * <br> EApGprsMinPrecedence |
|
138 * <br> EApGprsMinDelay |
|
139 * <br> EApGprsMinReliability |
|
140 * <br> EApGprsMinPeakThroughput |
|
141 * <br> EApGprsMinMeanThroughput |
|
142 * <br> EApWapWspOption |
|
143 * <br> EApIspBearerCallTypeIsdn |
|
144 * <br> EApProxyPortNumber |
|
145 * <br> EApNetworkID |
|
146 * <br> EApWapProxyPort |
|
147 * <br> EApIapBearerService |
|
148 * <br> EApIapBearerID |
|
149 * <br> |
|
150 * <br>Bool: |
|
151 * <br>ReadBool( const TApMember aColumn, TBool& aValue ) |
|
152 * <br>WriteBool( const TApMember aColumn, const TBool& aValue ) |
|
153 * <br> EApWapSecurity |
|
154 * <br> EApIspDialResolution |
|
155 * <br> EApIspUseLoginScript |
|
156 * <br> EApIspPromptForLogin |
|
157 * <br> EApIspDisplayPCT |
|
158 * <br> EApIspIfPromptForAuth |
|
159 * <br> EApGprsIfPromptForAuth |
|
160 * <br> EApIspIfCallbackEnabled |
|
161 * <br> EApIspIPAddrFromServer |
|
162 * <br> EApGprsIpAddrFromServer |
|
163 * <br> EApIspIPDnsAddrFromServer |
|
164 * <br> EApGprsIpDnsAddrFromServer |
|
165 * <br> EApIspEnableIpHeaderComp |
|
166 * <br> EApGprsHeaderCompression |
|
167 * <br> EApIspEnableLCPExtensions |
|
168 * <br> EApGprsEnableLCPExtensions |
|
169 * <br> EApIspDisablePlainTextAuth |
|
170 * <br> EApGprsDisablePlainTextAuth |
|
171 * <br> EApIspEnableSWCompression |
|
172 * <br> EApGprsDataCompression |
|
173 * <br> EApGprsUseAnonymAccess |
|
174 * <br> EApIsReadOnly |
|
175 * <br> EApProxyUseProxy |
|
176 * <br> EApHasProxySettings |
|
177 * <br> EApIP6DNSAddrFromServer |
|
178 */ |
|
179 enum TApMember |
|
180 { |
|
181 // WAP Access Point Table |
|
182 EApWapAccessPointID, ///< The Uid of the access point. |
|
183 ///< READ ONLY, assigned by the database. |
|
184 EApWapAccessPointName, ///< The name of the access point |
|
185 EApWapCurrentBearer, ///< Indicates the name of the table from |
|
186 ///< which to read the bearer information |
|
187 EApWapStartPage, ///< WAP start page URL, LONG TEXT! |
|
188 |
|
189 // WAP Common (present in both tables) |
|
190 EApWapGatewayAddress, ///< WAP gateway address (IP address) |
|
191 EApWapWspOption, ///< Enum value indicating whether |
|
192 ///< connection-oriented or connectionless |
|
193 ///< API should be used. |
|
194 ///< Type is TCommsDbWapWspOption. |
|
195 EApWapSecurity, ///< Attepmt secure WTLS connection to |
|
196 ///< the gateway |
|
197 |
|
198 // WAP IP Bearer Table |
|
199 //* DEPRECATED |
|
200 EApWapIsp, ///< Identifier of the ISP to use if this |
|
201 ///< is an ISP type database |
|
202 //* DEPRECATED |
|
203 EApWapChargecard, ///< Identifier for the chargecard to use |
|
204 ///< if this is an ISP type database |
|
205 EApWapIap, ///< Identifier of a record in the IAP |
|
206 ///< table to be used if this is an IAP |
|
207 ///< type database |
|
208 //* DEPRECATED |
|
209 EApWapIspType, ///< Enum value indicating whether IAP/ISP |
|
210 ///< is a dial in or a dial out |
|
211 |
|
212 // WAP SMS Bearer Table |
|
213 // EApSmsWapGatewayAddress is mapped to EApWapGatewayAddress, |
|
214 // different enum needed only for being able to |
|
215 // distinguish when editing... |
|
216 |
|
217 // IAP Table |
|
218 EApIapName, ///< The name of this IAP |
|
219 EApIapServiceType, ///< Name of service table in this IAP |
|
220 EApIapServiceId, ///< Identifier of service in this IAP |
|
221 EApIapChargecard, ///< Identifier of the chargecard in |
|
222 ///< this IAP |
|
223 |
|
224 // ISP table |
|
225 EApIspName, ///< The name of this ISP |
|
226 EApIspDescription, ///< Application's description of this ISP |
|
227 EApIspIspType, ///< Enum value indicating ISP type, e.g. |
|
228 ///< Internet ISP, WAP Isp.TCommsDbIspType. |
|
229 EApIspDefaultTelNumber, ///< Default phone number |
|
230 EApIspDialResolution, ///< Perform dialing resolution for default |
|
231 ///< phone number? |
|
232 EApIspUseLoginScript, ///< Use login script? |
|
233 EApIspLoginScript, ///< Login script (used only if Use Login |
|
234 ///< Script is true), LONG TEXT. |
|
235 EApIspPromptForLogin, ///< Prompt user for username and password? |
|
236 EApIspLoginName, ///< Login name |
|
237 EApIspLoginPass, ///< Login password |
|
238 EApIspDisplayPCT, ///< Display PCT (without scanning script |
|
239 ///< for READ command) UNUSED, always FALSE |
|
240 EApIspIfName, ///< Interface name |
|
241 EApIspIfParams, ///< Interface parameter string |
|
242 EApIspIfNetworks, ///< Comma separated list of network |
|
243 ///< protocols |
|
244 EApIspIfPromptForAuth, ///< Prompt user for authentication |
|
245 ///< username and password? |
|
246 EApIspIfAuthName, ///< Authentication username used by PPP |
|
247 EApIspIfAuthPass, ///< Authentication password used by PPP |
|
248 EApIspAuthRetries, ///< Number of times to retry |
|
249 ///< authentication if it fails |
|
250 EApIspIfCallbackEnabled, ///< Is callback enabled? |
|
251 EApIspIfCallbackType, ///< Enum value indicating the type of |
|
252 ///< callback (if enabled). |
|
253 ///< enum TCallbackAction. |
|
254 EApIspIfCallbackInfo, ///< Info for callback request (if enabled) |
|
255 ///< 8-bit text field. |
|
256 EApIspCallBackTimeOut, ///< Time to wait for callback in |
|
257 ///< microseconds (if enabled) |
|
258 EApIspIPAddrFromServer, ///< Get IP address from server? |
|
259 EApIspIPAddr, ///< IP address of interface |
|
260 EApIspIPNetMask, ///< IP net mask of interface |
|
261 EApIspIPGateway, ///< IP address of gateway |
|
262 EApIspIPDnsAddrFromServer, ///< Get DNS address from server? |
|
263 EApIspIPNameServer1, ///< IP address of primary name server |
|
264 EApIspIPNameServer2, ///< IP address of secondary name server |
|
265 EApIspEnableIpHeaderComp, ///< Enable IP header compression? |
|
266 EApIspEnableLCPExtensions, ///< Enable LCP extensions? |
|
267 EApIspDisablePlainTextAuth, ///< Disable plain text authentication? |
|
268 EApIspEnableSWCompression, ///< Enable software compression? |
|
269 EApIspBearerName, ///< Enum value specifying the name of the |
|
270 ///< bearer, e.g. Asunchronous Modem, |
|
271 ///< RBasicGsmCall::TBearerName |
|
272 EApIspBearerSpeed, ///< Enum value specifying the bearer speed |
|
273 ///< TApCallSpeed. |
|
274 EApIspBearerCallTypeIsdn, ///< call type is ISDN or Analogue... |
|
275 EApIspBearerCE, ///< Enum value specifying the bearer CE, |
|
276 ///< RBasicGsmCall::TBearerCE |
|
277 EApIspInitString, ///< Modem initialization string to be used |
|
278 ///< when this ISP is in use.This string |
|
279 ///< will be copied into the |
|
280 ///< MODEM_ISP_INIT_STRING field by |
|
281 ///< NetDial. 8-bit text field. |
|
282 EApIspBearerType, ///< Enum value indicating connection type |
|
283 ///< (CSD or HSCSD), TCommsDbBearerType |
|
284 EApIspChannelCoding, ///< Enum value specifying HSCSD channel |
|
285 ///< coding |
|
286 EApIspAIUR, ///< Enum value specifying AIUR for HSCSD |
|
287 EApIspRequestedTimeSlots, ///< Requested number of time slots for |
|
288 ///< HSCSD |
|
289 EApIspMaximumTimeSlots, ///< Maximum number of time slots for HSCSD |
|
290 ///< which could be requested during this |
|
291 ///< connection |
|
292 |
|
293 EApGprsAccessPointName, ///< Access Point Name, LONG TEXT! |
|
294 EApGprsPdpType, ///< PDP type |
|
295 EApGprsPdpAddress, ///< PDP address |
|
296 EApGprsReqPrecedence, ///< Requested quality of service |
|
297 ///< precedence class |
|
298 EApGprsReqDelay, ///< Requested quality of service |
|
299 ///< delay class |
|
300 EApGprsReqReliability, ///< Requested quality of service |
|
301 ///< reliability class |
|
302 EApGprsReqPeakThroughput, ///< Requested quality of service |
|
303 ///< peak throughput class |
|
304 EApGprsReqMeanPeakThroughput, ///< Requested quality of service |
|
305 ///< mean throughput class |
|
306 EApGprsMinPrecedence, ///< Minimum quality of service |
|
307 ///< precedence class |
|
308 EApGprsMinDelay, ///< Minimum quality of service |
|
309 ///< delay class |
|
310 EApGprsMinReliability, ///< Minimum quality of service |
|
311 ///< reliability class |
|
312 EApGprsMinPeakThroughput, ///< Minimum quality of service |
|
313 ///< peak throughput class |
|
314 EApGprsMinMeanThroughput, ///< Minimum quality of service |
|
315 ///< mean throughput class |
|
316 EApGprsUseAnonymAccess, ///< Use anonymous access on? |
|
317 |
|
318 // followings are mapped to ISP... fields |
|
319 EApGprsDataCompression, ///< Data compression on? |
|
320 EApGprsHeaderCompression, ///< IP header compression on? |
|
321 EApGprsIfName, ///< Interface name |
|
322 EApGprsIfParams, ///< Interface parameter string |
|
323 EApGprsIfNetworks, ///< Comma separated list of network |
|
324 ///< protocols |
|
325 EApGprsIfPromptForAuth, ///< Prompt user for authentication |
|
326 ///< username and password? |
|
327 EApGprsIfAuthName, ///< Authentication username used by PPP |
|
328 EApGprsIfAuthPassword, ///< Authentication password used by PPP |
|
329 EApGprsIfAuthRetries, ///< Number of times to retry |
|
330 ///< authentication if it fails |
|
331 EApGprsIpNetMask, ///< IP net mask of interface |
|
332 EApGprsIpGateway, ///< IP address of gateway |
|
333 EApGprsIpAddrFromServer, ///< Get IP adresses (for Symbian OS) |
|
334 ///< from server? |
|
335 EApGprsIpAddr, ///< IP address of Symbian OS |
|
336 EApGprsIpDnsAddrFromServer, ///< Get DNS addresses from server? |
|
337 EApGprsIPNameServer1, ///< IP address of primary name server |
|
338 EApGprsIPNameServer2, ///< IP address of secondary name server |
|
339 EApGprsEnableLCPExtensions, ///< Enable LCP extension? |
|
340 EApGprsDisablePlainTextAuth, ///< Disable plain text authentication? |
|
341 EApIsReadOnly ///< Is the current record read only? |
|
342 |
|
343 |
|
344 // expanding this enum is safe and will not cause any trouble as all public |
|
345 // part of this module uses it as a const parameter and NEVER as |
|
346 // a return value, therefore non-aware clients will NEVER meet with the new |
|
347 // ones, thus it can not cause any problems that they do not expect them... |
|
348 , |
|
349 EApProxyServerAddress, ///< Proxy server address, long text |
|
350 EApProxyProtocolName, ///< Proxy protocol name, Text |
|
351 EApProxyPortNumber, ///< Proxy port number, TUint32 |
|
352 EApProxyUseProxy, ///< Use proxy server?, TBool |
|
353 EApProxyExceptions, ///< ';' separated list of addr. for wich |
|
354 ///< the server should not be used. |
|
355 ///< Long text |
|
356 EApHasProxySettings, ///< Has proxy settings? READ ONLY. |
|
357 EApNetworkID, ///< The network ID |
|
358 EApNetworkName, ///< The network name |
|
359 |
|
360 EApWapProxyPort, ///< The wap proxy port number |
|
361 EApProxyLoginName, ///< The proxy login name |
|
362 EApProxyLoginPass, ///< The proxy login password |
|
363 EApIapBearerService, ///< Bearer service |
|
364 |
|
365 EApIP6DNSAddrFromServer, ///< Get IPv6 DNS addresses from server? |
|
366 EApIP6NameServer1, ///< IP address of primary name server |
|
367 EApIP6NameServer2, ///< IP address of secondary name server |
|
368 |
|
369 // CDMA2000 |
|
370 EApCdmaIwfName, ///< IWF name, Text |
|
371 EApCdmaServiceOption, ///< Service Option, TUint32 |
|
372 EApCdmaPdpType, ///< PDP type, TUin32 |
|
373 EApCdmaPdpAddress, ///< PDP address, Text |
|
374 EApCdmaReqFwdPriority, ///< Requested forward priority, TUint32 |
|
375 EApCdmaReqRevPriority, ///< Requested reverse priority, TUint32 |
|
376 EApCdmaReqFwdBitrate, ///< Requested forward bitrate, TUint32 |
|
377 EApCdmaReqRevBitrate, ///< Requested reverse bitrate, TUint32 |
|
378 EApCdmaReqFwdLoss, ///< Req. forward frame loss rate, TUint32 |
|
379 EApCdmaReqRevLoss, ///< Req. reverse frame loss rate, TUint32 |
|
380 EApCdmaReqFwdMaxDelay, ///< Requested forward delay, TUint32 |
|
381 EApCdmaReqRevMaxDelay, ///< Requested reverse delay, TUint32 |
|
382 EApCdmaMinFwdBitrate, ///< Min. acceptable fwd bitrate, TUint32 |
|
383 EApCdmaMinRevBitrate, ///< Min. acceptable rev bitrate, TUint32 |
|
384 EApCdmaAccptFwdLoss, ///< Max. acc. fwd frame loss rate, TUint32 |
|
385 EApCdmaAccptRevLoss, ///< Max. acc. rev frame loss rate, TUint32 |
|
386 EApCdmaAccptFwdMaxDelay, ///< Max. acceptable forward delay, TUint32 |
|
387 EApCdmaAccptRevMaxDelay, ///< Max. acceptable reverse delay, TUint32 |
|
388 |
|
389 // CDMA2000, mapped to ISP... fields |
|
390 EApCdmaDataCompression, ///< Data compression on? TBool |
|
391 EApCdmaHeaderCompression, ///< IP header compression on? TBool |
|
392 EApCdmaAnonymousAccess, ///< Use anonymous access on? TBool |
|
393 EApCdmaIfName, ///< Interface name |
|
394 EApCdmaIfParams, ///< Interface parameter string |
|
395 EApCdmaIfNetworks, ///< Comma separated list of network |
|
396 ///< protocols |
|
397 EApCdmaIfPromptForAuth, ///< Prompt user for authentication |
|
398 ///< username and password? |
|
399 EApCdmaIfAuthName, ///< Authentication username used by PPP |
|
400 EApCdmaIfAuthPassword, ///< Authentication password used by PPP |
|
401 EApCdmaIfAuthRetries, ///< Number of times to retry |
|
402 ///< authentication if it fails |
|
403 EApCdmaIpNetMask, ///< IP net mask of interface |
|
404 EApCdmaIpGateway, ///< IP address of gateway |
|
405 EApCdmaIpAddrFromServer, ///< Get IP adresses (for Symbian OS) |
|
406 ///< from server? |
|
407 EApCdmaIpAddr, ///< IP address of Symbian OS |
|
408 EApCdmaIpDnsAddrFromServer, ///< Get DNS addresses from server? |
|
409 EApCdmaIPNameServer1, ///< IP address of primary name server |
|
410 EApCdmaIPNameServer2, ///< IP address of secondary name server |
|
411 EApCdmaEnableLCPExtensions, ///< Enable LCP extension? |
|
412 EApCdmaDisablePlainTextAuth, ///< Disable plain text authentication? |
|
413 |
|
414 // CDMA2000 |
|
415 EApCdmaApType, ///< Internet / WAP or both? TUint32 |
|
416 EApCdmaQosWarningTimeout, ///< Notify user if the requested QOS |
|
417 ///< cannot be satisfied for this time in |
|
418 ///< microseconds, TUint32 |
|
419 EApCdmaRlpMode, ///< Transparent or non-transparent |
|
420 ///< radio link protocol, TUint32 |
|
421 // CDMA2000 deprecated Mobile IP fields |
|
422 EApCdmaMip, ///< Attempt to use mobile IP, TBool |
|
423 EApCdmaHomeAgentAddress, ///< Home Agent address, Text |
|
424 EApCdmaMipTimeout, ///< A normal reconnect (informing the |
|
425 ///< user) takes place if both the PPP link |
|
426 ///< drops and a change in SID or NID is |
|
427 ///< received within this time in |
|
428 ///< milliseconds, TUint32 |
|
429 // CDMA2000 specific CDMA parameters provisioned through OTA and defined |
|
430 // in TIA-683B section 3.5.8 |
|
431 // These fields replace the old Mobile IP fields (above). |
|
432 EApCdmaNaiType, ///< Type of NAI, TUint32 |
|
433 EApCdmaSimpleIpAuthAlgorithm, ///< SimpleIP auth.algorithm, TUint32 |
|
434 EApCdmaSimpleIpPapSsHandle, ///< SimpleIP PAP shared secret handle, |
|
435 ///< TUint32 |
|
436 EApCdmaSimpleIpChapSsHandle, ///< SimpleIP CHAP shared secret handle, |
|
437 ///< TUint32 |
|
438 EApCdmaMipTBit, ///< Reverse-tunneling reqd flag, TUint32 |
|
439 EApCdmaMipHomeAddress, ///< Home address, Text |
|
440 EApCdmaMipPrimaryHomeAgent, ///< IP address of mobile node's |
|
441 ///< primary home agent, Text |
|
442 EApCdmaMipSecondaryHomeAgent, ///< IP address of mobile node's |
|
443 ///< secondary home agent, Text |
|
444 EApCdmaMipMnAaaAuthAlgorithm, ///< MN-AAA auth algorithm, TUint32 |
|
445 EApCdmaMipMnAaaSpi, ///< MN-AAA security param index, TUint32 |
|
446 EApCdmaMipMnAaaSsHandle, ///< MN-AAA shared secret handle, TUint32 |
|
447 EApCdmaMipMnHaAuthAlgorithm, ///< MN-HA auth algorithm, TUint32 |
|
448 EApCdmaMipMnHaSpi, ///< MN-HA security param index, TUint32 |
|
449 EApCdmaMipMnHaSsHandle, ///< MN-HA shared secret handle, TUint32 |
|
450 |
|
451 |
|
452 // WLAN specific fields |
|
453 EApWlanNetworkName, ///< The network name, Text |
|
454 EApWlanNetworkMode, ///< Gives network mode, TUint32 |
|
455 EApWlanSecurityMode, ///< The security mode, TUint32 |
|
456 |
|
457 // WLAN, mapped to ISP... fields |
|
458 EApWlanIfNetworks, ///< Comma separated list of network |
|
459 ///< protocols |
|
460 EApWlanIfPromptForAuth, ///< Prompt user for authentication |
|
461 ///< username and password? |
|
462 EApWlanIfAuthName, ///< Authentication username used by PPP |
|
463 EApWlanIfAuthPassword, ///< Authentication password used by PPP |
|
464 EApWlanIfAuthRetries, ///< Number of times to retry |
|
465 ///< authentication if it fails |
|
466 EApWlanIpNetMask, ///< IP net mask of interface |
|
467 EApWlanIpGateway, ///< IP address of gateway |
|
468 EApWlanIpAddrFromServer, ///< Get IP adresses (for Symbian OS) |
|
469 ///< from server? |
|
470 EApWlanIpAddr, ///< IP address of Symbian OS |
|
471 EApWlanIpDnsAddrFromServer, ///< Get DNS addresses from server? |
|
472 EApWlanIPNameServer1, ///< IP address of primary name server |
|
473 EApWlanIPNameServer2, ///< IP address of secondary name server |
|
474 EApWlanSettingsId, ///< COMMDB_ID of the WLAN settings, |
|
475 ///< TUint32 |
|
476 EApWlanScanSSID, ///< TBool, whether need to scan the SSID |
|
477 EApWlanChannelId, ///< In ad-hoc network mode, the channel |
|
478 ///< ID, TUint32 |
|
479 EApLanBearerName, ///< The name of the LAN bearer |
|
480 EApIapBearerID, ///< UID of the bearer record (LAN/Modem) |
|
481 EApIapBearerType, ///< The name of the iap bearer |
|
482 ///< table (LAN/Modem) |
|
483 // some defines for UI ONLY, NOT TO BE USED BY ANYONE ELSE!!! |
|
484 EApIpv4Settings = 0x00010000, |
|
485 EApIpv6Settings, |
|
486 EApWlanSecuritySettings ///< The security settings launcher |
|
487 }; |
|
488 |
|
489 |
|
490 |
|
491 // CONSTANTS |
|
492 // D E P R E C A T E D, please do not use it!!!!!!!!!! |
|
493 // can not remove as it was part of the public API... |
|
494 const TInt KApMemberNum = EApGprsDisablePlainTextAuth+1; |
|
495 |
|
496 // FORWARD |
|
497 class CApItemExtra; |
|
498 |
|
499 // CLASS DECLARATION |
|
500 |
|
501 |
|
502 /** |
|
503 * CApAccessPointItem is used to exchange data between engine and client. |
|
504 * It holds the information for an access point including WAP, IAP, ISP |
|
505 * (if present & applies). |
|
506 * This class uses the same approach as CommDB to read and write data: it |
|
507 * has functions for each data type implemented. To read or write the data, |
|
508 * we have to know the data type and the enum name of the 'column'. |
|
509 * The column values has the names of the database columns with the 'EAp' |
|
510 * prefix. The reason for this (not using the database column descriptors) |
|
511 * is performance. It is much faster to compare enum values than literals. |
|
512 */ |
|
513 class CApAccessPointItem :public CBase |
|
514 { |
|
515 |
|
516 public: // Constructors and destructor |
|
517 /** |
|
518 * Two-phased constructor. Leaves on failure, places instance |
|
519 * on cleanup stack. Instance is initialised to default values. |
|
520 * The created instance is suitable for passing to CApDataHandler's |
|
521 * functions, contains all necessary information. |
|
522 * @return The constructed CApAccessPointItem. |
|
523 * |
|
524 * @deprecated |
|
525 */ |
|
526 IMPORT_C static CApAccessPointItem* NewLC(); |
|
527 |
|
528 |
|
529 /** |
|
530 * Destructor. |
|
531 * |
|
532 * @deprecated |
|
533 */ |
|
534 IMPORT_C virtual ~CApAccessPointItem(); |
|
535 |
|
536 |
|
537 /** |
|
538 * Copies the data from another CApAccessPointItem. |
|
539 * Substitute for the "assignment operator". It requires allocation |
|
540 * thus can leave. |
|
541 * Wap Access Point Uid is not copied. |
|
542 * |
|
543 * @deprecated |
|
544 */ |
|
545 IMPORT_C void CopyFromL( const CApAccessPointItem& aCopyFrom ); |
|
546 |
|
547 |
|
548 /** |
|
549 * Equality operator. Wap Access Point Uid is not counted. |
|
550 * |
|
551 * @deprecated |
|
552 */ |
|
553 IMPORT_C TBool operator==( const CApAccessPointItem& aitem ) const; |
|
554 |
|
555 |
|
556 /** |
|
557 * Inequality operator. Wap Access Point Uid is not counted. |
|
558 * |
|
559 * @deprecated |
|
560 */ |
|
561 IMPORT_C TBool operator!=( const CApAccessPointItem& aitem ) const; |
|
562 |
|
563 |
|
564 protected: // Constructors |
|
565 |
|
566 /** |
|
567 * C++ default constructor. |
|
568 * |
|
569 * @deprecated |
|
570 */ |
|
571 IMPORT_C CApAccessPointItem(); |
|
572 |
|
573 /** |
|
574 * Second-phase constructor. |
|
575 * |
|
576 * @deprecated |
|
577 */ |
|
578 IMPORT_C void ConstructL(); |
|
579 |
|
580 |
|
581 |
|
582 |
|
583 public: // New functions |
|
584 |
|
585 |
|
586 /** |
|
587 * This function reads up an 8-bit text value from the specified column. |
|
588 * @param aColumn Enum value indicating the column to read. |
|
589 * @param aValue Reference to an 8-bit descriptor to hold the value |
|
590 * @return no return value |
|
591 * |
|
592 * @deprecated |
|
593 */ |
|
594 IMPORT_C void ReadTextL( const TApMember aColumn, TDes8& aValue ); |
|
595 |
|
596 /** |
|
597 * This function reads up a 16-bit text value from the specified column. |
|
598 * @param aColumn Enum value indicating the column to read. |
|
599 * @param aValue Reference to a 16-bit descriptor to hold the value |
|
600 * @return no return value |
|
601 * |
|
602 * @deprecated |
|
603 */ |
|
604 IMPORT_C void ReadTextL( const TApMember aColumn, TDes16& aValue ); |
|
605 |
|
606 /** |
|
607 * NOTE: This function is deprecated. Use ReadConstLongTextL! |
|
608 * This function reads up a long text value from the specified column. |
|
609 * The ownership is not passed to the caller. It means that the caller |
|
610 * should not delete the received value. |
|
611 * If the caller must take the ownership for any reason, must make a |
|
612 * copy and use that and delete the copy when no longer needed. |
|
613 * @param aColumn Enum value indicating the column to read. |
|
614 * @return A HBufC* to the value. |
|
615 * |
|
616 * @deprecated |
|
617 */ |
|
618 IMPORT_C HBufC* ReadLongTextL( const TApMember aColumn ); |
|
619 |
|
620 |
|
621 /** |
|
622 * This function reads up a long text value from the specified column. |
|
623 * The ownership is not passed to the caller. It means that the caller |
|
624 * should not delete the received value. |
|
625 * If the caller must take the ownership for any reason, must make a |
|
626 * copy and use that and delete the copy when no longer needed. |
|
627 * @param aColumn Enum value indicating the column to read. |
|
628 * @return A const HBufC* to the value. |
|
629 * |
|
630 * @deprecated |
|
631 */ |
|
632 IMPORT_C const HBufC* ReadConstLongTextL( const TApMember aColumn ); |
|
633 |
|
634 |
|
635 |
|
636 /** |
|
637 * This function reads the length of the text in the specified column. |
|
638 * @param aColumn Enum value indicating the column to read. |
|
639 * @return The length of the text in that column. |
|
640 * |
|
641 * @deprecated |
|
642 */ |
|
643 IMPORT_C TUint32 ReadTextLengthL( const TApMember aColumn ); |
|
644 |
|
645 |
|
646 /** |
|
647 * This function reads up a TUint32 value from the specified column. |
|
648 * In case the given value was not written to the database, |
|
649 * it will return KErrValueUnspecified. |
|
650 * If the specified column does not exist (that is, not part of the |
|
651 * database structure), it will Panic in debug builds and it will |
|
652 * return KErrInvalidColumn in release builds without Panicking. |
|
653 * Panic is used in debug builds because it indicates a programming |
|
654 * error. In release, it 'notifies' the caller about the error through |
|
655 * the return value but enables system to continue operation. |
|
656 * @param aColumn Enum value indicating the column to read. |
|
657 * @param aValue A reference to a TUint32 to hold the value |
|
658 * @return Error code. |
|
659 * |
|
660 * @deprecated |
|
661 */ |
|
662 IMPORT_C TInt ReadUint( const TApMember aColumn, TUint32& aValue ); |
|
663 |
|
664 /** |
|
665 * This function reads up a boolean value from the specified column. |
|
666 * If the specified column does not exist (that is, not part of the |
|
667 * database structure), it will Panic in debug builds and it will |
|
668 * return KErrInvalidColumn in release builds without Panicking. |
|
669 * Panic is used in debug builds because it indicates a programming |
|
670 * error. In release, it 'notifies' the caller about the error through |
|
671 * the return value but enables system to continue operation. |
|
672 * @param aColumn Enum value indicating the column to read. |
|
673 * @param aValue A reference to a boolean to hold the value |
|
674 * @return Error code. |
|
675 * |
|
676 * @deprecated |
|
677 */ |
|
678 IMPORT_C TInt ReadBool( const TApMember aColumn, TBool& aValue ); |
|
679 |
|
680 |
|
681 // Update |
|
682 /** |
|
683 * This function writes an 8-bit text value to the specified column. |
|
684 * If the specified column does not exist (that is, not part of the |
|
685 * database structure), it will Panic in debug builds and it will |
|
686 * return KErrInvalidColumn in release builds without Panicking. |
|
687 * Panic is used in debug builds because it indicates a programming |
|
688 * error. In release, it 'notifies' the caller about the error through |
|
689 * the return value but enables system to continue operation. |
|
690 * This function can Leave if the copying of the text does not succeed. |
|
691 * Possible leave codes are the system leave codes. |
|
692 * @param aColumn Enum value indicating the column to write. |
|
693 * @param aValue Reference to an 8-bit text descriptor to the value |
|
694 * @return Error code. |
|
695 * |
|
696 * @deprecated |
|
697 */ |
|
698 IMPORT_C TInt WriteTextL( const TApMember aColumn, |
|
699 const TDesC8& aValue ); |
|
700 |
|
701 /** |
|
702 * This function writes a 16-bit text value to the specified column. |
|
703 * If the specified column does not exist (that is, not part of the |
|
704 * database structure), it will Panic in debug builds and it will |
|
705 * return KErrInvalidColumn in release builds without Panicking. |
|
706 * Panic is used in debug builds because it indicates a programming |
|
707 * error. In release, it 'notifies' the caller about the error through |
|
708 * the return value but enables system to continue operation. |
|
709 * This function can Leave if the copying of the text does not succeed. |
|
710 * @param aColumn Enum value indicating the column to write. |
|
711 * @param aValue Reference to a 16-bit text descriptor to the value |
|
712 * @return Error code. |
|
713 * |
|
714 * @deprecated |
|
715 */ |
|
716 IMPORT_C TInt WriteTextL( const TApMember aColumn, |
|
717 const TDesC16& aValue ); |
|
718 |
|
719 /** |
|
720 * This function writes a long text value to the specified column. |
|
721 * If the specified column does not exist (that is, not part of the |
|
722 * database structure), it will Panic in debug builds and it will |
|
723 * return KErrInvalidColumn in release builds without Panicking. |
|
724 * Panic is used in debug builds because it indicates a programming |
|
725 * error. In release, it 'notifies' the caller about the error through |
|
726 * the return value but enables system to continue operation. |
|
727 * This function can Leave if the copying of the text does not succeed. |
|
728 * @param aColumn Enum value indicating the column to write. |
|
729 * @param aValue Reference to a 16-bit text descriptor to the value |
|
730 * @return Error code. |
|
731 * |
|
732 * @deprecated |
|
733 */ |
|
734 IMPORT_C TInt WriteLongTextL( const TApMember aColumn, |
|
735 const TDesC& aValue ); |
|
736 |
|
737 /** |
|
738 * This function writes a TUint32 value to the specified column. |
|
739 * If the specified column does not exist (that is, not part of the |
|
740 * database structure), it will Panic in debug builds and it will |
|
741 * return KErrInvalidColumn in release builds without Panicking. |
|
742 * Panic is used in debug builds because it indicates a programming |
|
743 * error. In release, it 'notifies' the caller about the error through |
|
744 * the return value but enables system to continue operation. |
|
745 * @param aColumn Enum value indicating the column to write. |
|
746 * @param aValue A const reference to a TUint32 value |
|
747 * @return Error code. |
|
748 * |
|
749 * @deprecated |
|
750 */ |
|
751 IMPORT_C TInt WriteUint( const TApMember aColumn, |
|
752 const TUint32& aValue ); |
|
753 |
|
754 /** |
|
755 * This function writes a boolean value to the specified column. |
|
756 * If the specified column does not exist (that is, not part of the |
|
757 * database structure), it will Panic in debug builds and it will |
|
758 * return KErrInvalidColumn in release builds without Panicking. |
|
759 * Panic is used in debug builds because it indicates a programming |
|
760 * error. In release, it 'notifies' the caller about the error through |
|
761 * the return value but enables system to continue operation. |
|
762 * @param aColumn Enum value indicating the column to write. |
|
763 * @param aValue A const reference to a boolean value |
|
764 * @return Error code. |
|
765 * |
|
766 * @deprecated |
|
767 */ |
|
768 IMPORT_C TInt WriteBool( const TApMember aColumn, |
|
769 const TBool& aValue ); |
|
770 |
|
771 |
|
772 // Query |
|
773 // COMMON |
|
774 /** |
|
775 * This function returns the ID of the access point |
|
776 * @return The ID of this access point |
|
777 * |
|
778 * @deprecated |
|
779 */ |
|
780 IMPORT_C TUint32 WapUid() const; |
|
781 |
|
782 |
|
783 /** |
|
784 * This function returns the name of the connection |
|
785 * Ownership is not passed. |
|
786 * @return The name of the connection |
|
787 * |
|
788 * @deprecated |
|
789 */ |
|
790 IMPORT_C const TDesC& ConnectionName() const; |
|
791 |
|
792 |
|
793 // WAP-spec. |
|
794 /** |
|
795 * This function returns the current WAP bearer for the access point |
|
796 * Ownership is not passed. |
|
797 * @return The current WAP bearer for the access point |
|
798 * |
|
799 * @deprecated |
|
800 */ |
|
801 IMPORT_C const TDesC& WapBearer() const; |
|
802 |
|
803 |
|
804 /** |
|
805 * This function returns the bearer type for the current access point |
|
806 * @return The current bearer type for the access point |
|
807 * |
|
808 * @deprecated |
|
809 */ |
|
810 IMPORT_C TApBearerType BearerTypeL(); |
|
811 |
|
812 |
|
813 /** |
|
814 * This function sets the bearer type for the current access point |
|
815 * @param aBearer TApBearerType enum indicating the desired bearer type. |
|
816 * @return No return value. |
|
817 * |
|
818 * @deprecated |
|
819 */ |
|
820 IMPORT_C void SetBearerTypeL( TApBearerType aBearer ); |
|
821 |
|
822 |
|
823 /** |
|
824 * This function writes a 16-bit text value to the 'name' fields |
|
825 * of the access point. |
|
826 * This includes: WAP_ACCESS_POINT, IAP, Dial/in/out/Gprs In/Out |
|
827 * table's COMM_DB_NAME fields. |
|
828 * These fields are (by TApMember): EApWapAccessPointName, EApIapName, |
|
829 * EApIspName. |
|
830 * It is useful if we need to use same names. |
|
831 * @param aValue A const reference to a 16-bit text descriptor to |
|
832 * the value. |
|
833 * @return No return value. |
|
834 * |
|
835 * @deprecated |
|
836 */ |
|
837 IMPORT_C void SetNamesL( const TDesC16& aValue ); |
|
838 |
|
839 |
|
840 /** |
|
841 * This function checks the integrity of the CApAccessPointItem. |
|
842 * Currently checks: |
|
843 * IF WAP_IP_BEARER, WAP_ISP_TYPE conforms to IAP_SERVICE_TYPE |
|
844 * @return Boolean indicating whether the sanity check has |
|
845 * passed(ETrue) or not(EFalse) |
|
846 * |
|
847 * @deprecated |
|
848 */ |
|
849 IMPORT_C TBool SanityCheckOk(); |
|
850 |
|
851 |
|
852 /** |
|
853 * This function compares this and the passed CApAccessPointItem |
|
854 * whether they have the same ISP and bearer |
|
855 * Returns true if the APs have the same phone number |
|
856 * @param aItem a CApAccessPointItem to compare with |
|
857 * @return whether the APs have the same isp and bearer |
|
858 * |
|
859 * @deprecated |
|
860 */ |
|
861 IMPORT_C TBool HasSameIspAndBearerL( CApAccessPointItem& aItem ); |
|
862 |
|
863 /** |
|
864 * This function returns whether the access point is read-only or not. |
|
865 * @return Whether the current access point is read-only or not. |
|
866 * |
|
867 * @deprecated |
|
868 */ |
|
869 IMPORT_C TBool IsReadOnly() const; |
|
870 |
|
871 public: // public, not exported, available only inside the ApEngine dll |
|
872 /** |
|
873 * Returnes whether the given access point is a VPN ap or not. |
|
874 */ |
|
875 TBool IsVpnAp() const; |
|
876 |
|
877 /** |
|
878 * Sets the current access point as VPN or as normal AP. |
|
879 * Internal use only! |
|
880 * @param aIsVpn a TBool specifiyng that the current AP is VPN or not. |
|
881 */ |
|
882 void SetVpnAp( TBool aIsVpn ); |
|
883 |
|
884 private: |
|
885 /** |
|
886 * Returns whether a given member is specified (after reading it from |
|
887 * the DB) or not. |
|
888 * @param aMember The member we would like to knopw if it is specified |
|
889 * or not. |
|
890 * @return whether a given member is specified (after reading it from |
|
891 * the DB) or not. |
|
892 */ |
|
893 TBool Specified( TApMember aMember ); |
|
894 |
|
895 /** |
|
896 * Sets a given member as specified or not |
|
897 * @param aMember The member to set |
|
898 * @param aOn The value to set |
|
899 */ |
|
900 void Specify( TApMember aMember, TBool aOn ); |
|
901 |
|
902 /** |
|
903 * Sets all WAP member as specified or not |
|
904 * @param aOn The value to set |
|
905 */ |
|
906 void SpecifyWap( TBool aOn ); |
|
907 |
|
908 /** |
|
909 * Sets all IP bearer member as specified or not |
|
910 * @param aOn The value to set |
|
911 */ |
|
912 void SpecifyIpBearer( TBool aOn ); |
|
913 |
|
914 /** |
|
915 * Sets all IAP member as specified or not |
|
916 * @param aOn The value to set |
|
917 */ |
|
918 void SpecifyIAP( TBool aOn ); |
|
919 |
|
920 /** |
|
921 * Sets all ISP member as specified or not |
|
922 * @param aOn The value to set |
|
923 */ |
|
924 void SpecifyISP( TBool aOn ); |
|
925 |
|
926 /** |
|
927 * Sets all GPRS member as specified or not |
|
928 * @param aOn The value to set |
|
929 */ |
|
930 void SpecifyGPRS( TBool aOn ); |
|
931 |
|
932 /** |
|
933 * Sets all CDMA member as specified or not |
|
934 * @param aOn The value to set |
|
935 */ |
|
936 void SpecifyCDMA( TBool aOn ); |
|
937 |
|
938 /** |
|
939 * Sets all WLAN member as specified or not |
|
940 * @param aOn The value to set |
|
941 */ |
|
942 void SpecifyWLAN( TBool aOn ); |
|
943 |
|
944 /** |
|
945 * Sets all member as specified or not |
|
946 * @param aOn The value to set |
|
947 */ |
|
948 void SpecifyAll( TBool aOn ); |
|
949 |
|
950 /** |
|
951 * Sets iGetDNSIPFromServer according the currently valid iPrimaryDNS |
|
952 * & iSecondaryDNS values. Called internally, after every setting of |
|
953 * the above two values |
|
954 */ |
|
955 void SetDnsIpFromServer(); |
|
956 |
|
957 /** |
|
958 * Sets iIspIPAddrFromServer according the currently valid iIspIPAddr |
|
959 * value. Called internally, after every setting of iIspIPAddr values |
|
960 */ |
|
961 void SetIpFromServer(); |
|
962 |
|
963 |
|
964 /** |
|
965 * Sets iExt->iIpv6GetDNSIPFromServer according the currently valid |
|
966 * iExt->iIpv6PrimaryDNS & iExt->iIpv6SecondaryDNS values. |
|
967 * Called internally, after every setting of the above two values |
|
968 */ |
|
969 void SetDns6IpFromServer(); |
|
970 |
|
971 |
|
972 /** |
|
973 * Reallocates a passed 16-bit descriptor. Passed descriptor is deleted, |
|
974 * new one is AllocL-ed |
|
975 * Passed descriptor MUST NOT BE on the CleanupStack |
|
976 * @param aDes The descriptor to hold the value |
|
977 * @param aValue The value to pass to the aDes descriptor. |
|
978 */ |
|
979 void ReAllocL(HBufC*& aDes, const TDesC16& aValue); |
|
980 |
|
981 /** |
|
982 * Reallocates a passed 8-bit descriptor. Passed descriptor is deleted, |
|
983 * new one is AllocL-ed |
|
984 * Passed descriptor MUST NOT BE on the CleanupStack |
|
985 * @param aDes The descriptor to hold the value |
|
986 * @param aValue The value to pass to the aDes descriptor. |
|
987 */ |
|
988 void ReAllocL(HBufC8*& aDes, const TDesC8& aValue); |
|
989 |
|
990 |
|
991 /** |
|
992 * Compares THIS and the passed aItem. |
|
993 * @param aItem The item to compare this to |
|
994 * @return Whether the item is equal with this or not |
|
995 */ |
|
996 TBool DoCompareApL( const CApAccessPointItem& aItem ) const; |
|
997 |
|
998 |
|
999 /** |
|
1000 * Compares the WAP part of THIS and the passed aItem. |
|
1001 * Does not compares IAP ID |
|
1002 * @param aItem The item to compare this to |
|
1003 * @return Whether the WAP part is equal with this or not |
|
1004 */ |
|
1005 TBool CompareWap( const CApAccessPointItem& aItem ) const; |
|
1006 |
|
1007 |
|
1008 /** |
|
1009 * Compares the IAP part of THIS and the passed aItem. |
|
1010 * @param aItem The item to compare this to |
|
1011 * @return Whether the IAP part is equal with this or not |
|
1012 */ |
|
1013 TBool CompareIap( const CApAccessPointItem& aItem ) const; |
|
1014 |
|
1015 |
|
1016 /** |
|
1017 * Compares the IsP part of THIS and the passed aItem. |
|
1018 * @param aItem The item to compare this to |
|
1019 * @return Whether the ISP part is equal with this or not |
|
1020 */ |
|
1021 TBool CompareIsp( const CApAccessPointItem& aItem ) const; |
|
1022 |
|
1023 |
|
1024 /** |
|
1025 * Compares the Gprs part of THIS and the passed aItem. |
|
1026 * @param aItem The item to compare this to |
|
1027 * @return Whether the GPRS part is equal with this or not |
|
1028 */ |
|
1029 TBool CompareGprs( const CApAccessPointItem& aItem ) const; |
|
1030 |
|
1031 |
|
1032 /** |
|
1033 * Compares the Cdma part of THIS and the passed aItem. |
|
1034 * @param aItem The item to compare this to |
|
1035 * @return Whether the CDMA part is equal with this or not |
|
1036 */ |
|
1037 TBool CompareCdma( const CApAccessPointItem& aItem ) const; |
|
1038 |
|
1039 |
|
1040 /** |
|
1041 * Compares the Wlan part of THIS and the passed aItem. |
|
1042 * @param aItem The item to compare this to |
|
1043 * @return Whether the WLAN part is equal with this or not |
|
1044 */ |
|
1045 TBool CompareWlan( const CApAccessPointItem& aItem ) const; |
|
1046 |
|
1047 |
|
1048 /** |
|
1049 * Removes leading 0s from the passed IP address. |
|
1050 * @param aValue A descriptor holding the IP address to remove |
|
1051 * leading 0s from |
|
1052 * @return A newly allocated HBufC holding the resulting string. |
|
1053 */ |
|
1054 HBufC* GetCleanIpAddressLC( const TDesC& aValue ); |
|
1055 |
|
1056 |
|
1057 |
|
1058 /** |
|
1059 * Removes invalid chars e.g. space, () from the passed phone number. |
|
1060 * (valid are 0,1,2,..9,p,w,+,*,#) |
|
1061 * Strips pre- and postfixes, prefix separator is#, |
|
1062 * postfix separators are p, w or + |
|
1063 * @param aValue A descriptor holding the phone number |
|
1064 * @return A newly allocated HBufC holding the resulting string. |
|
1065 */ |
|
1066 HBufC* GetPlainPhoneNumberLC( const TDesC& aNumber ); |
|
1067 |
|
1068 |
|
1069 /** |
|
1070 * Compares the 'default phone number' (ISP dial-in number) of this |
|
1071 * and the passed CApAccessPointItem |
|
1072 * @param aItem The item to compare this to |
|
1073 * @return a TBool indicating whether the phone numbers are |
|
1074 * the same or not. |
|
1075 */ |
|
1076 TBool IsSamePhoneNumberL( CApAccessPointItem& aItem ); |
|
1077 |
|
1078 |
|
1079 /** |
|
1080 * Removes invalid chars from the passed phone number |
|
1081 * @param aIntext Text to remove invalid characters from phone number |
|
1082 * @return a HBufC holding the new text |
|
1083 */ |
|
1084 HBufC* RemoveInvalidPhoneCharsLC( const TDesC16& aInText ); |
|
1085 |
|
1086 |
|
1087 /** |
|
1088 * Removes invalid chars from the passed text |
|
1089 * Invalid chars are: TAB |
|
1090 * @param aIntext Text to remove invalid characters from |
|
1091 * @return a HBufC16 holding the new text |
|
1092 */ |
|
1093 HBufC* RemoveInvalidCharsLC( const TDesC16& aInText ); |
|
1094 |
|
1095 |
|
1096 /** |
|
1097 * Removes invalid chars from the passed text |
|
1098 * Invalid chars are: TAB |
|
1099 * @param aIntext Text to remove invalid characters from |
|
1100 * @return a HBufC8 holding the new text |
|
1101 */ |
|
1102 HBufC8* RemoveInvalidCharsLC( const TDesC8& aInText ); |
|
1103 |
|
1104 |
|
1105 /** |
|
1106 * Compares the proxy data of this and the passed CApAccessPointItem. |
|
1107 * @param aItem The item to compare this to |
|
1108 * @return Whether the Proxy part is equal with this or not |
|
1109 */ |
|
1110 TBool CompareProxy( const CApAccessPointItem& aItem ) const; |
|
1111 |
|
1112 |
|
1113 /** |
|
1114 * Returns whether the Ap has proxy data or not. |
|
1115 * @return Whether the Ap has proxy data or not. |
|
1116 */ |
|
1117 TBool HasProxy() const; |
|
1118 |
|
1119 |
|
1120 /** |
|
1121 * Sets the proxy flag. |
|
1122 */ |
|
1123 void SetProxyFlag(); |
|
1124 |
|
1125 |
|
1126 /** |
|
1127 * Limits the speed after changing e.g. bearer type |
|
1128 */ |
|
1129 void LimitSpeedL(); |
|
1130 |
|
1131 |
|
1132 /** |
|
1133 * Sets the IfNetworks value according to the bearer type and |
|
1134 * the IPv6 support availability. The required values are: |
|
1135 * IPv4: |
|
1136 * GPRS/CDMA, pdptype ipv4 "ip", |
|
1137 * CSD "ip" |
|
1138 * HSCSD "ip" |
|
1139 * IPv6: |
|
1140 * GPRS/CDMA, pdptype ipv4 "ip", |
|
1141 * GPRS/CDMA, pdptype ipv6 "ip6", |
|
1142 * CSD "ip,ip6" |
|
1143 * HSCSD "ip,ip6" |
|
1144 * |
|
1145 */ |
|
1146 void SetIfNetworksL(); |
|
1147 |
|
1148 |
|
1149 /** |
|
1150 * Check if aColumn is supported. |
|
1151 * @param aColumn Enum value indicating the column to check. |
|
1152 * @return Whether the given member is supported or not |
|
1153 */ |
|
1154 TBool IsSupported( TApMember aColumn ); |
|
1155 |
|
1156 |
|
1157 /** |
|
1158 * Leave with KErrNotSupported if aColumn is not supported. |
|
1159 * @param aColumn Enum value indicating the column to check. |
|
1160 */ |
|
1161 void LeaveIfUnsupportedL( TApMember aColumn ); |
|
1162 |
|
1163 |
|
1164 /** |
|
1165 * Returns whether this item has WLAN or not |
|
1166 * @return Whether this item has WLAN or not |
|
1167 */ |
|
1168 TBool IsWlan(); |
|
1169 |
|
1170 |
|
1171 /** |
|
1172 * Limit the Ip6 DNS address |
|
1173 * In case of CSD, HSCSD, only Well-known and User defined is supported, |
|
1174 * so if the bearer is changed from something else to these bearer |
|
1175 * types, the possible 'Dynamic' should be replaced with Well-known |
|
1176 */ |
|
1177 void LimitIp6DNSL(); |
|
1178 |
|
1179 private: // Data |
|
1180 |
|
1181 // member data |
|
1182 // COMMON |
|
1183 TUint32 iWapUid; ///< The unique identifier of the AP record. |
|
1184 HBufC* iWapAccessPointName; |
|
1185 |
|
1186 |
|
1187 // WAP-spec. |
|
1188 HBufC* iWapBearer; |
|
1189 HBufC* iStartingPage; |
|
1190 |
|
1191 // common for bearers |
|
1192 HBufC* iWapGatewayAddress; ///< The WAP gateway address |
|
1193 TBool iIsWTLSSecurityOn; |
|
1194 TUint32 iIsConnectionTypeContinuous; |
|
1195 |
|
1196 CApItemExtra* iExt; |
|
1197 TUint32 iChargeCard; |
|
1198 TUint32 iWapIap; |
|
1199 TUint32 iWapIspType; // deprecated, not used but kept |
|
1200 // to keep member positions |
|
1201 |
|
1202 |
|
1203 // IAP-part |
|
1204 HBufC* iIapName; |
|
1205 |
|
1206 TUint32 iIapServiceId; |
|
1207 HBufC* iIapServiceType; |
|
1208 |
|
1209 TUint32 iIapChargeCardId; |
|
1210 |
|
1211 // ISP-part |
|
1212 HBufC* iIspName; |
|
1213 HBufC* iIspDescription; |
|
1214 TCommsDbIspType iIspType; |
|
1215 HBufC* iIspDefaultTelNumber; |
|
1216 TBool iIspDialResolution; |
|
1217 TBool iUseLoginScript; |
|
1218 HBufC* iLoginScript; |
|
1219 TBool iPromptPassword; |
|
1220 HBufC* iUserName; |
|
1221 HBufC* iPassword; |
|
1222 TBool iDisplayTerminalWindow; |
|
1223 HBufC* iIspIfName; |
|
1224 HBufC* iIspIfParams; |
|
1225 HBufC* iIspIfNetworks; |
|
1226 TBool iIspIfPromptForAuth; |
|
1227 HBufC* iIspIfAuthName; |
|
1228 HBufC* iIspIfAuthPass; |
|
1229 TUint32 iIspIfAuthRetries; |
|
1230 TBool iUseCallBack; |
|
1231 TCallbackAction iCallBackTypeIsServerNum; |
|
1232 HBufC8* iIspIfCallbackInfo; |
|
1233 TUint32 iIspCallbackTimeOut; |
|
1234 TBool iIspIPAddrFromServer; |
|
1235 HBufC* iIspIPAddr; |
|
1236 HBufC* iIspIPNetMask; |
|
1237 HBufC* iIspGateway; |
|
1238 TBool iGetDNSIPFromServer; |
|
1239 HBufC* iPrimaryDNS; |
|
1240 HBufC* iSecondaryDNS; |
|
1241 TBool iEnablePPPCompression; |
|
1242 TBool iIspEnableLCPExtensions; |
|
1243 TBool iIsPasswordAuthenticationSecure; |
|
1244 TBool iIspEnableSwCompression; |
|
1245 /***************************************************** |
|
1246 * Series 60 Customer / ETel |
|
1247 * Series 60 ETel API |
|
1248 *****************************************************/ |
|
1249 TInt iIspBearerName; // RMobileCall::TMobileCallDataServiceCaps |
|
1250 TApCallSpeed iMaxConnSpeed; |
|
1251 TApCallType iBearerCallTypeIsdn; //RMobileCall::TMobileCallDataProtocol |
|
1252 TInt iIspBearerCE; // RMobileCall::TMobileCallDataQoS |
|
1253 HBufC8* iIspInitString; |
|
1254 TUint32 iIspBearerType; |
|
1255 TUint32 iIspChannelCoding; |
|
1256 TUint32 iIspAIUR; |
|
1257 TUint32 iIspRequestedTimeSlots; |
|
1258 TUint32 iIspMaximumTimeSlots; |
|
1259 |
|
1260 // GPRS part |
|
1261 HBufC* iGprsAccessPointName; |
|
1262 TUint32 iGprsPdpType; |
|
1263 HBufC* iGprsPdpAddress; |
|
1264 TUint32 iGprsReqPrecedence; |
|
1265 TUint32 iGprsReqDelay; |
|
1266 TUint32 iGprsReqReliability; |
|
1267 TUint32 iGprsReqPeakThroughput; |
|
1268 TUint32 iGprsReqMeanPeakThroughput; |
|
1269 TUint32 iGprsMinPrecedence; |
|
1270 |
|
1271 TUint32 iGprsMinDelay; |
|
1272 TUint32 iGprsMinReliability; |
|
1273 TUint32 iGprsMinPeakThroughput; |
|
1274 TUint32 iGprsMinMeanThroughput; |
|
1275 TBool iGprsUseAnonymAccess; |
|
1276 |
|
1277 CArrayFixFlat<TBool> *iSpecified; |
|
1278 TBool iIsReadOnly; |
|
1279 |
|
1280 HBufC* iApProxyProtocolName; |
|
1281 HBufC* iApProxyServerAddress; |
|
1282 TUint32 iApProxyPortNumber; |
|
1283 TBool iApProxyUseProxy; |
|
1284 HBufC* iApProxyExceptions; |
|
1285 TBool iApHasProxySettings; |
|
1286 |
|
1287 TUint32 iNetworkId; |
|
1288 TUint32 iWapProxyPort; |
|
1289 HBufC* iNetworkName; |
|
1290 HBufC* iWapProxyLoginName; |
|
1291 HBufC* iWapProxyLoginPass; |
|
1292 TUint32 iApIapBearerService; // RMobileCall::TMobileCallDataServiceCaps |
|
1293 |
|
1294 |
|
1295 |
|
1296 protected: // Friend classes |
|
1297 friend class CApDataHandler; |
|
1298 |
|
1299 |
|
1300 }; |
|
1301 |
|
1302 #endif // ACCESSPOINTITEM_H |
|
1303 |
|
1304 // End of File |