|
1 /* |
|
2 * Copyright (c) 2009-2010 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: |
|
15 * WLAN Qt Utilities private implementation. |
|
16 */ |
|
17 |
|
18 // System includes |
|
19 |
|
20 #include <QSharedPointer> |
|
21 |
|
22 // User includes |
|
23 |
|
24 #include "wlanqtutilsap.h" |
|
25 #include "wlanqtutilsiap.h" |
|
26 #include "wlanqtutilsconnection.h" |
|
27 #include "wlanqtutilsiapsettings.h" |
|
28 #include "wlanqtutilsconmonwrapper.h" |
|
29 #include "wlanqtutilsesockwrapper.h" |
|
30 #include "wlanqtutilsscan.h" |
|
31 |
|
32 #include "wlanqtutils.h" |
|
33 #include "wlanqtutils_p.h" |
|
34 |
|
35 #include "OstTraceDefinitions.h" |
|
36 #ifdef OST_TRACE_COMPILER_IN_USE |
|
37 #include "wlanqtutils_pTraces.h" |
|
38 #endif |
|
39 |
|
40 /*! |
|
41 \class WlanQtUtilsPrivate |
|
42 \brief Private implementation class for WLAN Qt Utilities. |
|
43 |
|
44 The private interface functions are identical to those in WlanQtUtils |
|
45 class, so refer to that for descriptions. Other functions contain |
|
46 implementation documentation. |
|
47 */ |
|
48 |
|
49 |
|
50 // External function prototypes |
|
51 |
|
52 // Local constants |
|
53 |
|
54 // ======== LOCAL FUNCTIONS ======== |
|
55 |
|
56 // ======== MEMBER FUNCTIONS ======== |
|
57 |
|
58 /*! |
|
59 Constructor. |
|
60 */ |
|
61 |
|
62 WlanQtUtilsPrivate::WlanQtUtilsPrivate(WlanQtUtils *q_ptr) : |
|
63 q_ptr(q_ptr), |
|
64 mSettings(new WlanQtUtilsIapSettings(this)), |
|
65 mConMonWrapper(new WlanQtUtilsConMonWrapper(this)), |
|
66 mScanWrapper(new WlanQtUtilsScan(this)), |
|
67 mEsockWrapper(new WlanQtUtilsEsockWrapper(this)), |
|
68 mIctService(), |
|
69 mScanMode(ScanModeNone), |
|
70 mIapScanList(), |
|
71 mWlanScanList(), |
|
72 mToBeTestedIapId(WlanQtUtils::IapIdNone), |
|
73 mConnectingIapId(WlanQtUtils::IapIdNone), |
|
74 mConnection() |
|
75 { |
|
76 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_ENTRY, this); |
|
77 |
|
78 // Make all connections. |
|
79 bool connectStatus = connect( |
|
80 mScanWrapper, |
|
81 SIGNAL(availableWlanIaps(QList< QSharedPointer<WlanQtUtilsIap> > &)), |
|
82 this, |
|
83 SLOT(updateAvailableWlanIaps(QList< QSharedPointer<WlanQtUtilsIap> > &))); |
|
84 Q_ASSERT(connectStatus); |
|
85 |
|
86 connectStatus = connect( |
|
87 mScanWrapper, |
|
88 SIGNAL(availableWlanAps(QList< QSharedPointer<WlanQtUtilsAp> >&)), |
|
89 this, |
|
90 SLOT(updateAvailableWlanAps(QList< QSharedPointer<WlanQtUtilsAp> >&))); |
|
91 Q_ASSERT(connectStatus); |
|
92 |
|
93 connectStatus = connect( |
|
94 mScanWrapper, |
|
95 SIGNAL(scanFailed(int)), |
|
96 this, |
|
97 SLOT(reportScanResult(int))); |
|
98 Q_ASSERT(connectStatus); |
|
99 |
|
100 connectStatus = connect( |
|
101 mEsockWrapper, |
|
102 SIGNAL(connectionStatusFromWrapper(bool)), |
|
103 this, |
|
104 SLOT(updateConnectionStatus(bool))); |
|
105 Q_ASSERT(connectStatus); |
|
106 |
|
107 connectStatus = connect( |
|
108 mConMonWrapper, |
|
109 SIGNAL(connCreatedEventFromWrapper(uint)), |
|
110 this, |
|
111 SLOT(addActiveConnection(uint))); |
|
112 Q_ASSERT(connectStatus); |
|
113 |
|
114 connectStatus = connect( |
|
115 mConMonWrapper, |
|
116 SIGNAL(connDeletedEventFromWrapper(uint)), |
|
117 this, |
|
118 SLOT(removeActiveConnection(uint))); |
|
119 Q_ASSERT(connectStatus); |
|
120 |
|
121 connectStatus = connect( |
|
122 mConMonWrapper, |
|
123 SIGNAL(connStatusEventFromWrapper(uint, WlanQtUtils::ConnStatus)), |
|
124 this, |
|
125 SLOT(updateActiveConnection(uint, WlanQtUtils::ConnStatus))); |
|
126 Q_ASSERT(connectStatus); |
|
127 |
|
128 // Retrieve initial status of active connections |
|
129 mConnection = QSharedPointer<WlanQtUtilsConnection>( |
|
130 mConMonWrapper->activeConnection()); |
|
131 |
|
132 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATE_EXIT, this); |
|
133 } |
|
134 |
|
135 /*! |
|
136 Destructor. |
|
137 */ |
|
138 |
|
139 WlanQtUtilsPrivate::~WlanQtUtilsPrivate() |
|
140 { |
|
141 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_ENTRY, this); |
|
142 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_WLANQTUTILSPRIVATEDESTR_EXIT, this); |
|
143 } |
|
144 |
|
145 /*! |
|
146 See WlanQtUtils::scanWlans(). |
|
147 */ |
|
148 |
|
149 void WlanQtUtilsPrivate::scanWlans() |
|
150 { |
|
151 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANS_ENTRY, this); |
|
152 |
|
153 // Scanning while there is an ongoing scan is not supported |
|
154 Q_ASSERT(mScanMode == ScanModeNone); |
|
155 |
|
156 // Starting with an IAP scan, and continuing with AP scan |
|
157 mScanMode = ScanModeAvailableWlans; |
|
158 mScanWrapper->scanWlanIaps(); |
|
159 |
|
160 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANS_EXIT, this); |
|
161 } |
|
162 |
|
163 /*! |
|
164 See WlanQtUtils::scanWlanAps(). |
|
165 */ |
|
166 |
|
167 void WlanQtUtilsPrivate::scanWlanAps() |
|
168 { |
|
169 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANAPS_ENTRY, this); |
|
170 |
|
171 // Scanning while there is an ongoing scan is not supported |
|
172 Q_ASSERT(mScanMode == ScanModeNone); |
|
173 |
|
174 // Just forward the request to wrapper, which triggers a broadcast WLAN scan |
|
175 mScanMode = ScanModeAvailableWlanAps; |
|
176 mScanWrapper->scanWlanAps(); |
|
177 |
|
178 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANAPS_EXIT, this); |
|
179 } |
|
180 |
|
181 /*! |
|
182 See WlanQtUtils::scanWlanDirect(). |
|
183 */ |
|
184 |
|
185 void WlanQtUtilsPrivate::scanWlanDirect(const QString &ssid) |
|
186 { |
|
187 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_ENTRY, this); |
|
188 |
|
189 // Scanning while there is an ongoing scan is not supported |
|
190 Q_ASSERT(mScanMode == ScanModeNone); |
|
191 |
|
192 // Just forward the request to wrapper, which triggers a direct WLAN scan |
|
193 mScanMode = ScanModeDirect; |
|
194 mScanWrapper->scanWlanDirect(ssid); |
|
195 |
|
196 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_SCANWLANDIRECT_EXIT, this); |
|
197 } |
|
198 |
|
199 /*! |
|
200 See WlanQtUtils::stopWlanScan(). |
|
201 */ |
|
202 |
|
203 void WlanQtUtilsPrivate::stopWlanScan() |
|
204 { |
|
205 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_STOPWLANSCAN_ENTRY, this); |
|
206 |
|
207 if (mScanMode != ScanModeNone) { |
|
208 // Inform that scan was cancelled |
|
209 reportScanResult(WlanQtUtils::ScanStatusCancelled); |
|
210 |
|
211 // Stop the scan |
|
212 mScanMode = ScanModeNone; |
|
213 mScanWrapper->stopScan(); |
|
214 } |
|
215 |
|
216 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_STOPWLANSCAN_EXIT, this); |
|
217 } |
|
218 |
|
219 /*! |
|
220 See WlanQtUtils::availableWlans(). |
|
221 */ |
|
222 |
|
223 void WlanQtUtilsPrivate::availableWlans( |
|
224 QList< QSharedPointer<WlanQtUtilsIap> > &wlanIapList, |
|
225 QList< QSharedPointer<WlanQtUtilsAp> > &wlanApList) const |
|
226 { |
|
227 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_ENTRY, this); |
|
228 |
|
229 wlanIapList.clear(); |
|
230 wlanApList.clear(); |
|
231 |
|
232 // Read the list of configured IAPs |
|
233 QList< QSharedPointer<WlanQtUtilsIap> > configuredIapList; |
|
234 mSettings->fetchIaps(configuredIapList); |
|
235 |
|
236 // Update the list of available IAPs |
|
237 foreach (QSharedPointer<WlanQtUtilsIap> iapIter, mIapScanList) { |
|
238 int iapId = iapIter->value(WlanQtUtilsIap::ConfIdIapId).toInt(); |
|
239 QSharedPointer<WlanQtUtilsIap> iap(mSettings->fetchIap(iapId)); |
|
240 if (iap) { |
|
241 // Only add the IAP if we (still) have the settings for it |
|
242 iap->setValue( |
|
243 WlanQtUtilsAp::ConfIdSignalStrength, |
|
244 iapIter->value(WlanQtUtilsAp::ConfIdSignalStrength)); |
|
245 wlanIapList.append(iap); |
|
246 } |
|
247 } |
|
248 |
|
249 // Go through the scan results to find unknown APs |
|
250 for (int i = 0; i < mWlanScanList.count(); i++) { |
|
251 // Check whether an IAP with these parameters exists (in which |
|
252 // case this network is already added as an IAP in the loop above) |
|
253 if (!wlanIapExists(configuredIapList, mWlanScanList[i].data())) { |
|
254 // No IAP found in, copy the AP to caller's list of |
|
255 // unknown APs |
|
256 wlanApList.append(mWlanScanList[i]); |
|
257 } |
|
258 } |
|
259 |
|
260 traceIapsAndAps(wlanIapList, wlanApList); |
|
261 |
|
262 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLAN_EXIT, this); |
|
263 } |
|
264 |
|
265 /*! |
|
266 See WlanQtUtils::availableWlanAps(). |
|
267 */ |
|
268 |
|
269 void WlanQtUtilsPrivate::availableWlanAps( |
|
270 QList< QSharedPointer<WlanQtUtilsAp> > &wlanApList) const |
|
271 { |
|
272 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_ENTRY, this); |
|
273 |
|
274 // Just copy the results |
|
275 wlanApList = mWlanScanList; |
|
276 |
|
277 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_AVAILABLEWLANAPS_EXIT, this); |
|
278 } |
|
279 |
|
280 /*! |
|
281 See WlanQtUtils::createIap(). |
|
282 */ |
|
283 |
|
284 int WlanQtUtilsPrivate::createIap(const WlanQtUtilsAp *wlanAp) |
|
285 { |
|
286 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CREATEIAP_ENTRY, this); |
|
287 |
|
288 // Create the new IAP and return its ID |
|
289 int newIapId = mSettings->createIap(wlanAp); |
|
290 |
|
291 OstTrace1( |
|
292 TRACE_BORDER, |
|
293 WLANQTUTILSPRIVATE_CREATEIAP, |
|
294 "WlanQtUtilsPrivate::createIap;New IAP ID=%d", |
|
295 newIapId); |
|
296 |
|
297 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CREATEIAP_EXIT, this); |
|
298 return newIapId; |
|
299 } |
|
300 |
|
301 /*! |
|
302 See WlanQtUtils::updateIap(). |
|
303 */ |
|
304 |
|
305 bool WlanQtUtilsPrivate::updateIap(int iapId, const WlanQtUtilsAp *wlanAp) |
|
306 { |
|
307 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEIAP_ENTRY, this); |
|
308 |
|
309 bool success = mSettings->updateIap(iapId, wlanAp); |
|
310 |
|
311 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEIAP_EXIT, this); |
|
312 return success; |
|
313 } |
|
314 |
|
315 /*! |
|
316 See WlanQtUtils::deleteIap(). |
|
317 */ |
|
318 |
|
319 void WlanQtUtilsPrivate::deleteIap(int iapId) |
|
320 { |
|
321 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DELETEIAP_ENTRY, this); |
|
322 |
|
323 mSettings->deleteIap(iapId); |
|
324 |
|
325 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DELETEIAP_EXIT, this); |
|
326 } |
|
327 |
|
328 /*! |
|
329 See WlanQtUtils::connectIap(). |
|
330 */ |
|
331 |
|
332 void WlanQtUtilsPrivate::connectIap(int iapId, bool runIct) |
|
333 { |
|
334 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_CONNECTIAP_ENTRY, this); |
|
335 |
|
336 OstTraceExt2( |
|
337 TRACE_BORDER, |
|
338 WLANQTUTILSPRIVATE_CONNECTIAP, |
|
339 "WlanQtUtilsPrivate::connectIap;IAP ID=%d;runIct=%hhu", |
|
340 iapId, |
|
341 runIct); |
|
342 |
|
343 Q_ASSERT(iapId != WlanQtUtils::IapIdNone); |
|
344 |
|
345 if (runIct) { |
|
346 // Mark this IAP for ICT testing after it has been opened |
|
347 mToBeTestedIapId = iapId; |
|
348 } |
|
349 mConnectingIapId = iapId; |
|
350 mEsockWrapper->connectIap(iapId); |
|
351 |
|
352 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_CONNECTIAP_EXIT, this); |
|
353 } |
|
354 |
|
355 /*! |
|
356 See WlanQtUtils::disconnectIap(). |
|
357 */ |
|
358 |
|
359 void WlanQtUtilsPrivate::disconnectIap(int iapId) |
|
360 { |
|
361 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_DISCONNECTIAP_ENTRY, this); |
|
362 |
|
363 OstTrace1( |
|
364 TRACE_BORDER, |
|
365 WLANQTUTILSPRIVATE_DISCONNECTIAP, |
|
366 "WlanQtUtilsPrivate::disconnectIap;IAP ID=%d", |
|
367 iapId); |
|
368 |
|
369 if (iapId != WlanQtUtils::IapIdNone) { |
|
370 // Close our RConnection handle, if needed. Wrapper ignores call, if |
|
371 // no handle exists. |
|
372 mEsockWrapper->disconnectIap(); |
|
373 |
|
374 // In order to close connection even if there are other users for the |
|
375 // IAP, close also via ConMon |
|
376 mConMonWrapper->disconnectIap(iapId); |
|
377 } // else: just ignore call |
|
378 |
|
379 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_DISCONNECTIAP_EXIT, this); |
|
380 } |
|
381 |
|
382 /*! |
|
383 See WlanQtUtils::connectionStatus(). |
|
384 */ |
|
385 |
|
386 WlanQtUtils::ConnStatus WlanQtUtilsPrivate::connectionStatus() const |
|
387 { |
|
388 OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_ENTRY); |
|
389 |
|
390 WlanQtUtils::ConnStatus status = WlanQtUtils::ConnStatusDisconnected; |
|
391 |
|
392 if (mConnection) { |
|
393 status = mConnection->connectionStatus(); |
|
394 } |
|
395 OstTrace1( |
|
396 TRACE_BORDER, |
|
397 WLANQTUTILSPRIVATE_CONNECTIONSTATUS, |
|
398 "WlanQtUtilsPrivate::connectionStatus;status=%{ConnStatus};", |
|
399 (TUint)status); |
|
400 |
|
401 OstTraceFunctionExit0(WLANQTUTILSPRIVATE_CONNECTIONSTATUS_EXIT); |
|
402 return status; |
|
403 } |
|
404 |
|
405 /*! |
|
406 See WlanQtUtils::activeIap(). |
|
407 */ |
|
408 |
|
409 int WlanQtUtilsPrivate::activeIap() const |
|
410 { |
|
411 OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_ACTIVEIAP_ENTRY); |
|
412 |
|
413 int iapId = WlanQtUtils::IapIdNone; |
|
414 |
|
415 if (mConnection) { |
|
416 iapId = mConnection->iapId(); |
|
417 } |
|
418 OstTrace1( |
|
419 TRACE_BORDER, |
|
420 WLANQTUTILSPRIVATE_ACTIVEIAP, |
|
421 "WlanQtUtilsPrivate::activeIap;iapId=%d", |
|
422 iapId); |
|
423 |
|
424 OstTraceFunctionExit0(WLANQTUTILSPRIVATE_ACTIVEIAP_EXIT); |
|
425 return iapId; |
|
426 } |
|
427 |
|
428 /*! |
|
429 See WlanQtUtils::iapName(). |
|
430 */ |
|
431 |
|
432 QString WlanQtUtilsPrivate::iapName(int iapId) const |
|
433 { |
|
434 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_IAPNAME_ENTRY, this); |
|
435 |
|
436 QString name; |
|
437 // Read the IAP from settings and return its name |
|
438 QSharedPointer<WlanQtUtilsIap> iap = mSettings->fetchIap(iapId); |
|
439 if (iap) { |
|
440 name = iap->value(WlanQtUtilsIap::ConfIdName).toString(); |
|
441 } |
|
442 |
|
443 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_IAPNAME_EXIT, this); |
|
444 return name; |
|
445 } |
|
446 |
|
447 /*! |
|
448 This function searches for a WLAN IAP matching the given WLAN AP. |
|
449 |
|
450 @param [in] list List to search from. |
|
451 @param [in] ap Access point to search for. |
|
452 |
|
453 @return True, if suitable WLAN IAP found, false otherwise. |
|
454 */ |
|
455 |
|
456 bool WlanQtUtilsPrivate::wlanIapExists( |
|
457 const QList< QSharedPointer<WlanQtUtilsIap> > list, |
|
458 const WlanQtUtilsAp *ap) const |
|
459 { |
|
460 bool match = false; // Return value |
|
461 |
|
462 foreach (QSharedPointer<WlanQtUtilsIap> iap, list) { |
|
463 if (WlanQtUtilsAp::compare(iap.data(), ap) == 0) { |
|
464 // Match found |
|
465 match = true; |
|
466 break; |
|
467 } |
|
468 } |
|
469 |
|
470 return match; |
|
471 } |
|
472 |
|
473 /*! |
|
474 This function traces the given IAPs and APs. |
|
475 |
|
476 @param [in] iaps IAPs to trace. |
|
477 @param [in] aps APs to trace. |
|
478 */ |
|
479 |
|
480 void WlanQtUtilsPrivate::traceIapsAndAps( |
|
481 const QList<QSharedPointer<WlanQtUtilsIap> > &iaps, |
|
482 const QList<QSharedPointer<WlanQtUtilsAp> > &aps) const |
|
483 { |
|
484 #ifndef OST_TRACE_COMPILER_IN_USE |
|
485 Q_UNUSED(iaps); |
|
486 Q_UNUSED(aps); |
|
487 #else |
|
488 foreach (QSharedPointer<WlanQtUtilsIap> iap, iaps) { |
|
489 QString tmp(iap->value(WlanQtUtilsIap::ConfIdName).toString()); |
|
490 TPtrC16 name(tmp.utf16(), tmp.length()); |
|
491 OstTraceExt3( |
|
492 TRACE_NORMAL, |
|
493 WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_IAP, |
|
494 "WlanQtUtilsPrivate::traceAvailableWlanAps IAP;name=%S;secMode=%{WlanSecMode};signalStrength=%d", |
|
495 name, |
|
496 iap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(), |
|
497 iap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt()); |
|
498 } |
|
499 foreach (QSharedPointer<WlanQtUtilsAp> ap, aps) { |
|
500 QString tmp(ap->value(WlanQtUtilsAp::ConfIdSsid).toString()); |
|
501 TPtrC16 ssid(tmp.utf16(), tmp.length()); |
|
502 OstTraceExt3( |
|
503 TRACE_NORMAL, |
|
504 WLANQTUTILSPRIVATE_TRACEAVAILABLEWLANAPS_AP, |
|
505 "WlanQtUtilsPrivate::traceAvailableWlanAps AP;ssid=%S;secMode=%{WlanSecMode};signalStrength=%d", |
|
506 ssid, |
|
507 ap->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt(), |
|
508 ap->value(WlanQtUtilsAp::ConfIdSignalStrength).toInt()); |
|
509 } |
|
510 #endif |
|
511 } |
|
512 |
|
513 /*! |
|
514 Slot for handling WLAN IAP scan result event from wrapper. Results are |
|
515 stored in a member variable. |
|
516 |
|
517 @param [in] availableIaps Available WLAN IAP's found in scan. |
|
518 */ |
|
519 |
|
520 void WlanQtUtilsPrivate::updateAvailableWlanIaps( |
|
521 QList< QSharedPointer<WlanQtUtilsIap> > &availableIaps) |
|
522 { |
|
523 OstTraceFunctionEntry0(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANIAPS_ENTRY); |
|
524 |
|
525 // Store the new IAP list |
|
526 mIapScanList = availableIaps; |
|
527 |
|
528 // Continue with AP scan (which should come immediately from WLAN's scan cache) |
|
529 mScanWrapper->scanWlanAps(); |
|
530 |
|
531 OstTraceFunctionExit0(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANIAPS_EXIT); |
|
532 } |
|
533 |
|
534 /*! |
|
535 Slot for handling WLAN AP scan result event from wrapper. Results are |
|
536 stored in member variable (possible duplicates are removed). |
|
537 |
|
538 @param [in] availableWlanList WLAN networks found in scan. |
|
539 */ |
|
540 |
|
541 void WlanQtUtilsPrivate::updateAvailableWlanAps( |
|
542 QList< QSharedPointer<WlanQtUtilsAp> > &availableWlanList) |
|
543 { |
|
544 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_ENTRY, this); |
|
545 |
|
546 // Old results are removed |
|
547 mWlanScanList.clear(); |
|
548 |
|
549 // Copy available WLANs to scan result list (duplicates are removed) |
|
550 for (int i = 0; i < availableWlanList.count(); i++) { |
|
551 bool duplicate = false; |
|
552 for (int j = 0; j < mWlanScanList.count(); j++) { |
|
553 if (WlanQtUtilsAp::compare( |
|
554 availableWlanList[i].data(), |
|
555 mWlanScanList[j].data()) == 0) { |
|
556 duplicate = true; |
|
557 break; |
|
558 } |
|
559 } |
|
560 if (duplicate == false) { |
|
561 mWlanScanList.append(availableWlanList[i]); |
|
562 } |
|
563 } |
|
564 |
|
565 // The information is forwarded to the client |
|
566 reportScanResult(WlanQtUtils::ScanStatusOk); |
|
567 |
|
568 // Scan is complete |
|
569 mScanMode = ScanModeNone; |
|
570 |
|
571 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEAVAILABLEWLANAPS_EXIT, this); |
|
572 } |
|
573 |
|
574 /*! |
|
575 Scan result handler. Reports the scanning result to the client. |
|
576 |
|
577 @param [in] status Scan status code (WlanQtUtils::ScanStatus). |
|
578 */ |
|
579 |
|
580 void WlanQtUtilsPrivate::reportScanResult(int status) |
|
581 { |
|
582 switch (mScanMode) { |
|
583 case ScanModeAvailableWlans: |
|
584 OstTrace1( |
|
585 TRACE_BORDER, |
|
586 WLANQTUTILSPRIVATE_WLANSCANREADY, |
|
587 "WlanQtUtilsPrivate::reportScanResult emit wlanScanReady;status=%{ScanStatus};", |
|
588 status); |
|
589 emit q_ptr->wlanScanReady(status); |
|
590 break; |
|
591 |
|
592 case ScanModeAvailableWlanAps: |
|
593 OstTrace1( |
|
594 TRACE_BORDER, |
|
595 WLANQTUTILSPRIVATE_WLANSCANAPREADY, |
|
596 "WlanQtUtilsPrivate::reportScanResult emit wlanScanApReady;status=%{ScanStatus};", |
|
597 status); |
|
598 emit q_ptr->wlanScanApReady(status); |
|
599 break; |
|
600 |
|
601 case ScanModeDirect: |
|
602 OstTrace1( |
|
603 TRACE_BORDER, |
|
604 WLANQTUTILSPRIVATE_WLANSCANDIRECTREADY, |
|
605 "WlanQtUtilsPrivate::reportScanResult emit wlanScanDirectReady;status=%{ScanStatus};", |
|
606 status); |
|
607 emit q_ptr->wlanScanDirectReady(status); |
|
608 break; |
|
609 |
|
610 #ifndef QT_NO_DEBUG |
|
611 default: |
|
612 // Invalid scan mode detected |
|
613 Q_ASSERT(0); |
|
614 break; |
|
615 #endif |
|
616 } |
|
617 } |
|
618 |
|
619 /*! |
|
620 Slot for handling connection setup status event from wrapper. |
|
621 |
|
622 @param [in] isOpened Was connection setup successful? |
|
623 */ |
|
624 |
|
625 void WlanQtUtilsPrivate::updateConnectionStatus(bool isOpened) |
|
626 { |
|
627 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_ENTRY, this); |
|
628 |
|
629 if (isOpened == false) { |
|
630 // Opening failed, update connection status and inform UI |
|
631 if (mConnection) { |
|
632 mConnection->setConnectionStatus( |
|
633 WlanQtUtils::ConnStatusDisconnected); |
|
634 } |
|
635 |
|
636 // Include the status code from connection wrapper |
|
637 int status = mEsockWrapper->lastStatusCode(); |
|
638 OstTraceExt2( |
|
639 TRACE_BORDER, |
|
640 WLANQTUTILSPRIVATE_WLANNETWORKCLOSED, |
|
641 "WlanQtUtilsPrivate::emit wlanNetworkClosed;IAP ID=%d;status=%d", |
|
642 mConnectingIapId, |
|
643 status); |
|
644 emit q_ptr->wlanNetworkClosed(mConnectingIapId, status); |
|
645 } else { |
|
646 // Opening succeeded, update connection status and inform UI |
|
647 if (mConnection) { |
|
648 mConnection->setConnectionStatus(WlanQtUtils::ConnStatusConnected); |
|
649 } |
|
650 |
|
651 OstTrace1( |
|
652 TRACE_BORDER, |
|
653 WLANQTUTILSPRIVATE_WLANNETWORKOPENED, |
|
654 "WlanQtUtilsPrivate::emit wlanNetworkOpened;IAP ID=%d", |
|
655 mConnectingIapId); |
|
656 emit q_ptr->wlanNetworkOpened(mConnectingIapId); |
|
657 |
|
658 // Start ICT, if needed |
|
659 if (mConnectingIapId == mToBeTestedIapId) { |
|
660 QSharedPointer<WlanQtUtilsIap> iap(mSettings->fetchIap(mConnectingIapId)); |
|
661 |
|
662 mIctService = QSharedPointer<IctsWlanLoginInterface>( |
|
663 new IctsWlanLoginInterface(this)); |
|
664 |
|
665 // IctsWlanLoginInterface instance is created for each connectivity test |
|
666 // Note: Queued connection is required since mIctService is deleted |
|
667 // when signal comes |
|
668 bool connectStatus = connect( |
|
669 mIctService.data(), |
|
670 SIGNAL(ictsResult(int)), |
|
671 this, |
|
672 SLOT(updateIctResult(int)), |
|
673 Qt::QueuedConnection); |
|
674 Q_ASSERT(connectStatus); |
|
675 connectStatus = connect( |
|
676 mIctService.data(), |
|
677 SIGNAL(hotspotCase()), |
|
678 this, |
|
679 SLOT(updateIctHotspotCase()), |
|
680 Qt::QueuedConnection); |
|
681 Q_ASSERT(connectStatus); |
|
682 |
|
683 mIctService->start( |
|
684 mToBeTestedIapId, |
|
685 iap->value(WlanQtUtilsIap::ConfIdNetworkId).toInt()); |
|
686 } |
|
687 } |
|
688 // IAP is no more in connecting state |
|
689 mConnectingIapId = WlanQtUtils::IapIdNone; |
|
690 |
|
691 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATECONNECTIONSTATUS_EXIT, this); |
|
692 } |
|
693 |
|
694 /*! |
|
695 Slot for handling internet connectivity test result event from wrapper. |
|
696 Tested IAP is stored to Internet SNAP, if test was successful. If the |
|
697 IAP needs Hotspot authentication, it remains ungategorized. |
|
698 |
|
699 @param [in] result Result of internet connectivity test and hotspot |
|
700 authentication (IctsWlanLoginInterface::ictsResultType). |
|
701 */ |
|
702 |
|
703 void WlanQtUtilsPrivate::updateIctResult(int ictsResult) |
|
704 { |
|
705 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEICTRESULT_ENTRY, this); |
|
706 |
|
707 Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); |
|
708 WlanQtUtils::IctStatus result = WlanQtUtils::IctFailed; |
|
709 |
|
710 if (ictsResult == IctsWlanLoginInterface::IctsPassed) { |
|
711 // Move the tested IAP to Internet SNAP since the test passed |
|
712 Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); |
|
713 mSettings->moveIapToInternetSnap(mToBeTestedIapId); |
|
714 result = WlanQtUtils::IctPassed; |
|
715 } else if (ictsResult == IctsWlanLoginInterface::IctsHotspotPassed) { |
|
716 Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); |
|
717 result = WlanQtUtils::IctHotspotPassed; |
|
718 } else if (ictsResult == IctsWlanLoginInterface::IctsCanceled) { |
|
719 Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); |
|
720 result = WlanQtUtils::IctCancelled; |
|
721 } else { |
|
722 // ICTS failed - IAP remains to be uncategorized and mIctService is deleted. |
|
723 mIctService.clear(); |
|
724 } |
|
725 |
|
726 // Inform UI |
|
727 OstTraceExt2( |
|
728 TRACE_NORMAL, |
|
729 WLANQTUTILSPRIVATE_ICTRESULT, |
|
730 "WlanQtUtilsPrivate::emit ictResult;iapId=%d;result=%{IctStatus}", |
|
731 mToBeTestedIapId, |
|
732 result); |
|
733 |
|
734 emit q_ptr->ictResult(mToBeTestedIapId, result); |
|
735 |
|
736 // This IAP is now tested |
|
737 mToBeTestedIapId = WlanQtUtils::IapIdNone; |
|
738 |
|
739 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEICTRESULT_EXIT, this); |
|
740 } |
|
741 |
|
742 /*! |
|
743 Slot for setting IAP to be tested as hotspot IAP. |
|
744 */ |
|
745 |
|
746 void WlanQtUtilsPrivate::updateIctHotspotCase() |
|
747 { |
|
748 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE_ENTRY, this); |
|
749 |
|
750 mSettings->setAsHotspotIap(mToBeTestedIapId); |
|
751 |
|
752 Q_ASSERT(mToBeTestedIapId != WlanQtUtils::IapIdNone); |
|
753 OstTrace1( |
|
754 TRACE_BORDER, |
|
755 WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE, |
|
756 "WlanQtUtilsPrivate::updateIctHotspotCase set as hotspot IAP;iapId=%d", |
|
757 mToBeTestedIapId); |
|
758 |
|
759 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEICTHOTSPOTCASE_EXIT, this); |
|
760 } |
|
761 |
|
762 /*! |
|
763 Slot for updating active connection status from wrapper. |
|
764 |
|
765 @param [in] connectionId ID of the new connection. |
|
766 */ |
|
767 |
|
768 void WlanQtUtilsPrivate::addActiveConnection(uint connectionId) |
|
769 { |
|
770 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_ENTRY, this); |
|
771 OstTrace1( |
|
772 TRACE_BORDER, |
|
773 WLANQTUTILSPRIVATE_ADDACTIVECONNECTION, |
|
774 "WlanQtUtilsPrivate::addActiveConnection;connectionId=%u", |
|
775 connectionId); |
|
776 |
|
777 Q_ASSERT(mConnection == NULL); |
|
778 mConnection = QSharedPointer<WlanQtUtilsConnection>( |
|
779 mConMonWrapper->connectionInfo(connectionId)); |
|
780 |
|
781 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_ADDACTIVECONNECTION_EXIT, this); |
|
782 } |
|
783 |
|
784 /*! |
|
785 Slot for updating active connection status from wrapper. |
|
786 |
|
787 @param [in] connectionId ID of the deleted connection. |
|
788 */ |
|
789 |
|
790 void WlanQtUtilsPrivate::removeActiveConnection(uint connectionId) |
|
791 { |
|
792 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_ENTRY, this); |
|
793 OstTrace1( |
|
794 TRACE_BORDER, |
|
795 WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION, |
|
796 "WlanQtUtilsPrivate::removeActiveConnection;connectionId=%u", |
|
797 connectionId); |
|
798 |
|
799 Q_ASSERT(mConnection); |
|
800 if (mConnection->connectionId() == connectionId) { |
|
801 int closedIapId = mConnection->iapId(); |
|
802 mConnection.clear(); |
|
803 |
|
804 if (mConnectingIapId != closedIapId) { |
|
805 // Connection is closed, inform UI. wlanNetworkClosed is sent |
|
806 // from here instead of updateActiveConnection(closed), |
|
807 // because, in some cases, connection may be removed without |
|
808 // any connection status updates. |
|
809 // Note: reason parameter is not accurate here, because it is |
|
810 // only relevant for connections opened by this dll |
|
811 // (updateConnectionStatus) |
|
812 OstTraceExt2( |
|
813 TRACE_BORDER, |
|
814 DUP1_WLANQTUTILSPRIVATE_WLANNETWORKCLOSED, |
|
815 "WlanQtUtilsPrivate::emit wlanNetworkClosed;iapID=%d;status=%d", |
|
816 closedIapId, |
|
817 KErrNone); |
|
818 emit q_ptr->wlanNetworkClosed(closedIapId, KErrNone); |
|
819 } |
|
820 // else: connection creation started by thid dll, but creation failed |
|
821 // -> wlanNetworkClosed is sent from updateConnectionStatus |
|
822 } |
|
823 |
|
824 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_REMOVEACTIVECONNECTION_EXIT, this); |
|
825 } |
|
826 |
|
827 /*! |
|
828 Slot for updating active connection status from wrapper. |
|
829 |
|
830 @param [in] connectionId ID of the updated connection. |
|
831 @param [in] connectionStatus New status of the connection. |
|
832 */ |
|
833 |
|
834 void WlanQtUtilsPrivate::updateActiveConnection( |
|
835 uint connectionId, |
|
836 WlanQtUtils::ConnStatus connectionStatus) |
|
837 { |
|
838 OstTraceFunctionEntry1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_ENTRY, this); |
|
839 OstTraceExt2( |
|
840 TRACE_BORDER, |
|
841 WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION, |
|
842 "WlanQtUtilsPrivate::updateActiveConnection;connectionId=%u;connectionStatus=%{ConnStatus}", |
|
843 connectionId, |
|
844 (uint)connectionStatus); |
|
845 |
|
846 Q_ASSERT(mConnection); |
|
847 if (mConnection->connectionId() == connectionId |
|
848 && mConnection->connectionStatus() != connectionStatus) { |
|
849 // Update connection status and inform UI, if necessary |
|
850 mConnection->setConnectionStatus(connectionStatus); |
|
851 if (connectionStatus == WlanQtUtils::ConnStatusConnected) { |
|
852 OstTrace1( |
|
853 TRACE_BORDER, |
|
854 DUP1_WLANQTUTILSPRIVATE_WLANNETWORKOPENED, |
|
855 "WlanQtUtilsPrivate::emit wlanNetworkOpened;iapId=%d", |
|
856 mConnection->iapId()); |
|
857 emit q_ptr->wlanNetworkOpened(mConnection->iapId()); |
|
858 } |
|
859 // Do not inform UI about connection closing here. It is done in |
|
860 // removeActiveConnection(), because that may occur without any |
|
861 // connection status updates. |
|
862 } // else: connection status did not change |
|
863 |
|
864 OstTraceFunctionExit1(WLANQTUTILSPRIVATE_UPDATEACTIVECONNECTION_EXIT, this); |
|
865 } |