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