|
1 /* |
|
2 * Copyright (c) 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 Login engine class implementation |
|
16 * |
|
17 */ |
|
18 |
|
19 // System includes |
|
20 #include <QObject> |
|
21 #include <QString> |
|
22 #include <QUrl> |
|
23 #include <HbMessagebox> |
|
24 #include <HbAction> |
|
25 #include <qnetworkconfigmanager.h> |
|
26 #include <qnetworkconfiguration.h> |
|
27 #include <qnetworksession.h> |
|
28 |
|
29 //User includes |
|
30 #include "wlanloginengine.h" |
|
31 #include "wlanloginapplication.h" |
|
32 #include "wlanloginmainwindow.h" |
|
33 #include "ictsqtwrapper.h" |
|
34 #include "wlanloginnetworkaccessmanager.h" |
|
35 |
|
36 #include "OstTraceDefinitions.h" |
|
37 #ifdef OST_TRACE_COMPILER_IN_USE |
|
38 #include "wlanloginengineTraces.h" |
|
39 #endif |
|
40 |
|
41 /*! |
|
42 \class WlanLoginEngine |
|
43 \brief WLAN Login engine class implementation. |
|
44 */ |
|
45 |
|
46 // External function prototypes |
|
47 |
|
48 // Local constants |
|
49 |
|
50 // ======== LOCAL FUNCTIONS ======== |
|
51 |
|
52 // ======== MEMBER FUNCTIONS ======== |
|
53 |
|
54 /*! |
|
55 Constructor. |
|
56 */ |
|
57 WlanLoginEngine::WlanLoginEngine(QObject *parent): |
|
58 QObject(parent), |
|
59 mEngineState(WaitingForStart), |
|
60 mServiceRequestCompleted(false), |
|
61 mNetConfigurationManager(new QNetworkConfigurationManager(this)), |
|
62 mNetworkAccessManager(new WlanLoginNetworkAccessManager(this)), |
|
63 mNetworkSession(NULL), |
|
64 mIctsWrapper(NULL), |
|
65 mIctsFirstRun(true), |
|
66 mIap(0), |
|
67 mNetId(0), |
|
68 mRedirectionUrl(QUrl("")) |
|
69 { |
|
70 OstTraceFunctionEntry0(WLANLOGINENGINE_WLANLOGINENGINE_ENTRY); |
|
71 |
|
72 bool connectStatus = connect( |
|
73 mNetConfigurationManager, |
|
74 SIGNAL(updateCompleted()), |
|
75 this, |
|
76 SLOT(handleUpdateCompleted())); |
|
77 Q_ASSERT(connectStatus == true); |
|
78 |
|
79 OstTraceFunctionExit0(WLANLOGINENGINE_WLANLOGINENGINE_EXIT); |
|
80 } |
|
81 |
|
82 |
|
83 /*! |
|
84 Destructor. |
|
85 */ |
|
86 WlanLoginEngine::~WlanLoginEngine() |
|
87 { |
|
88 OstTraceFunctionEntry0(WLANLOGINENGINE_DESTRUCTOR_ENTRY); |
|
89 |
|
90 mNetworkSession->close(); |
|
91 |
|
92 OstTraceFunctionExit0(WLANLOGINENGINE_DESTRUCTOR_EXIT); |
|
93 } |
|
94 |
|
95 |
|
96 /*! |
|
97 Function that returns pointer to network access manager. |
|
98 |
|
99 @return Pointer to WlanLoginNetworkAccessManager |
|
100 */ |
|
101 WlanLoginNetworkAccessManager* WlanLoginEngine::networkAccessManager() const |
|
102 { |
|
103 return mNetworkAccessManager; |
|
104 } |
|
105 |
|
106 |
|
107 /*! |
|
108 Function that returns current state of the engine. |
|
109 |
|
110 @return engine state |
|
111 */ |
|
112 WlanLoginEngine::EngineState WlanLoginEngine::engineState() |
|
113 { |
|
114 return mEngineState; |
|
115 } |
|
116 |
|
117 |
|
118 /*! |
|
119 Function that sets the current state of the engine. |
|
120 |
|
121 @param [in] newState New state of the engine to be set |
|
122 */ |
|
123 void WlanLoginEngine::setEngineState(WlanLoginEngine::EngineState newState) |
|
124 { |
|
125 mEngineState = newState; |
|
126 } |
|
127 |
|
128 |
|
129 /*! |
|
130 This slot handles startLogin signal from Qt Highway service provider |
|
131 |
|
132 @param [in] iapId Internet access point ID for a connection that we should attach to' |
|
133 @param [in] netId Network Id for the connection to be used |
|
134 @param [in] redirectionUrl The URL that we were redirected to by the first internet connectivity test |
|
135 |
|
136 */ |
|
137 void WlanLoginEngine::handleStartLogin(int iapId, int netId, QUrl redirectionUrl) |
|
138 { |
|
139 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESTARTLOGIN_ENTRY); |
|
140 |
|
141 mIap = iapId; |
|
142 OstTrace1( |
|
143 TRACE_NORMAL, |
|
144 WLANLOGINENGINE_HANDLESTARTLOGIN_IAP_TRACE, |
|
145 "WlanLoginEngine::handleStartLogin;mIap=%d", |
|
146 mIap); |
|
147 |
|
148 mNetId = netId; |
|
149 OstTrace1( |
|
150 TRACE_NORMAL, |
|
151 WLANLOGINENGINE_HANDLESTARTLOGIN_NETID_TRACE, |
|
152 "WlanLoginEngine::handleStartLogin;mNetId=%d", |
|
153 mNetId); |
|
154 |
|
155 mRedirectionUrl = redirectionUrl; |
|
156 |
|
157 #ifdef OST_TRACE_COMPILER_IN_USE |
|
158 QString url = mRedirectionUrl.toString(); |
|
159 TPtrC tmp(url.utf16(),url.length() ); |
|
160 |
|
161 OstTraceExt1( |
|
162 TRACE_NORMAL, |
|
163 WLANLOGINENGINE_HANDLESTARTLOGIN_URL_TRACE, |
|
164 "WlanLoginEngine::handleStartLogin;mRedirectionUrl=%S", |
|
165 tmp); |
|
166 #endif |
|
167 |
|
168 //Create ICTS instance as we know needed parameters now |
|
169 mIctsWrapper = new IctsWrapper(mIap, mNetId, this); |
|
170 |
|
171 bool connectStatus = connect( |
|
172 mIctsWrapper, |
|
173 SIGNAL(connectivityTestResult(IctsWrapper::ConnectivityTestResult, QUrl)), |
|
174 this, |
|
175 SLOT(handleConnectivityTestResult(IctsWrapper::ConnectivityTestResult, QUrl))); |
|
176 Q_ASSERT(connectStatus == true); |
|
177 |
|
178 //Update network configurations as only states of the cellular IAP's are reliable |
|
179 //after creating network configuration manager |
|
180 |
|
181 setEngineState(UpdatingNetworkConfigurations); |
|
182 mNetConfigurationManager->updateConfigurations(); |
|
183 |
|
184 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESTARTLOGIN_EXIT); |
|
185 } |
|
186 |
|
187 /*! |
|
188 This slot handles stopLogin signal from Qt Highway service provider |
|
189 |
|
190 */ |
|
191 void WlanLoginEngine::handleStopLogin() |
|
192 { |
|
193 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESTOPLOGIN_ENTRY); |
|
194 |
|
195 // Exit application |
|
196 qApp->quit(); |
|
197 |
|
198 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESTOPLOGIN_EXIT); |
|
199 } |
|
200 |
|
201 |
|
202 /*! |
|
203 This slot handles updateCompleted signal from QNetworkConfigManager |
|
204 |
|
205 */ |
|
206 void WlanLoginEngine::handleUpdateCompleted() |
|
207 { |
|
208 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLEUPDATECOMPLETED_ENTRY); |
|
209 |
|
210 //States of the available configurations are now updated and |
|
211 //we can open the network session to provided IAP |
|
212 |
|
213 openSession(); |
|
214 |
|
215 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLEUPDATECOMPLETED_EXIT); |
|
216 } |
|
217 |
|
218 /*! |
|
219 This function handles opening of the network session to the specified IAP. |
|
220 If IAP is not already in connected state, function completes service request |
|
221 with connection dropped status and show a message box to user. |
|
222 |
|
223 */ |
|
224 void WlanLoginEngine::openSession() |
|
225 { |
|
226 OstTraceFunctionEntry0(WLANLOGINENGINE_OPENSESSION_ENTRY); |
|
227 |
|
228 setEngineState(WlanLoginEngine::OpeningNetworkSession); |
|
229 |
|
230 //Get configuration that matches the provided IAP |
|
231 QNetworkConfiguration netConfiguration = mNetConfigurationManager->configurationFromIdentifier(QString::number(mIap)); |
|
232 |
|
233 OstTrace1( |
|
234 TRACE_NORMAL, |
|
235 WLANLOGINENGINE_OPENSESSION_CONFIGURATION_IDENTIFIER_TRACE, |
|
236 "WlanLoginEngine::openSession;netConfiguration identifier=%d", |
|
237 netConfiguration.identifier().toInt()); |
|
238 |
|
239 OstTrace1(TRACE_NORMAL, |
|
240 WLANLOGINENGINE_OPENSESSION_CONFIGURATION_STATE_TRACE, |
|
241 "WlanLoginEngine::openSession;netConfiguration state=%d", |
|
242 netConfiguration.state()); |
|
243 |
|
244 #ifdef OST_TRACE_COMPILER_IN_USE |
|
245 QString string = netConfiguration.name(); |
|
246 TPtrC tmp(string.utf16(),string.length() ); |
|
247 |
|
248 OstTraceExt1( |
|
249 TRACE_NORMAL, |
|
250 WLANLOGINENGINE_OPENSESSION_CONFIGURATION_NAME_TRACE, |
|
251 "WlanLoginEngine::openSession;netConfiguration name=%S", |
|
252 tmp ); |
|
253 |
|
254 string = netConfiguration.bearerName(); |
|
255 tmp.Set(string.utf16(),string.length()); |
|
256 |
|
257 OstTraceExt1( |
|
258 TRACE_NORMAL, |
|
259 WLANLOGINENGINE_OPENSESSION_CONFIGURATION_BEARER_NAME_TRACE, |
|
260 "WlanLoginEngine::openSession;netConfiguration bearerName=%S", |
|
261 tmp ); |
|
262 #endif |
|
263 |
|
264 //Check that configuration state is active before opening session |
|
265 //Otherwise show disconnected message box |
|
266 |
|
267 if (netConfiguration.state() == QNetworkConfiguration::Active) |
|
268 { |
|
269 //Create network session to IAP that was provided in startup |
|
270 mNetworkSession = new QNetworkSession(netConfiguration, this); |
|
271 |
|
272 bool connectStatus = connect( |
|
273 mNetworkSession, |
|
274 SIGNAL(opened()), |
|
275 this, |
|
276 SLOT(handleSessionOpened())); |
|
277 Q_ASSERT(connectStatus == true); |
|
278 |
|
279 connectStatus = connect( |
|
280 mNetworkSession, |
|
281 SIGNAL(stateChanged(QNetworkSession::State)), |
|
282 this, |
|
283 SLOT(handleSessionStateChanged(QNetworkSession::State))); |
|
284 Q_ASSERT(connectStatus == true); |
|
285 |
|
286 connectStatus = connect( |
|
287 mNetworkSession, |
|
288 SIGNAL(error(QNetworkSession::SessionError)), |
|
289 this, |
|
290 SLOT(handleSessionError(QNetworkSession::SessionError))); |
|
291 Q_ASSERT(connectStatus == true); |
|
292 |
|
293 mNetworkSession->open(); |
|
294 } else { |
|
295 showConnectionDroppedMessageBox(); |
|
296 } |
|
297 |
|
298 OstTraceFunctionExit0(WLANLOGINENGINE_OPENSESSION_EXIT); |
|
299 } |
|
300 |
|
301 |
|
302 /*! |
|
303 This function handles sessionOpened signal from QNetworkSession. It informs view that |
|
304 connection is ready to be used. |
|
305 |
|
306 */ |
|
307 void WlanLoginEngine::handleSessionOpened() |
|
308 { |
|
309 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESESSIONOPENED_ENTRY); |
|
310 |
|
311 setEngineState(NetworkSessionOpened); |
|
312 //Send indication to view that connection is ready |
|
313 emit connectionReady(mRedirectionUrl); |
|
314 |
|
315 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESESSIONOPENED_EXIT); |
|
316 } |
|
317 |
|
318 |
|
319 /*! |
|
320 This function handles sessionStateChanged signal from QNetworkSession. |
|
321 @param [in] newState New state of the session |
|
322 */ |
|
323 void WlanLoginEngine::handleSessionStateChanged(QNetworkSession::State newState) |
|
324 { |
|
325 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESESSIONSTATECHANGED_ENTRY); |
|
326 |
|
327 OstTrace1( |
|
328 TRACE_NORMAL, |
|
329 WLANLOGINENGINE_HANDLESESSIONSTATECHANGED_STATE_TRACE, |
|
330 "WlanLoginEngine::handleSessionStateChanged;newState=%d", |
|
331 newState ); |
|
332 |
|
333 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESESSIONSTATECHANGED_EXIT); |
|
334 } |
|
335 |
|
336 |
|
337 /*! |
|
338 This function handles sessionError signal from QNetworkSession |
|
339 @param [in] error session error |
|
340 */ |
|
341 void WlanLoginEngine::handleSessionError(QNetworkSession::SessionError error) |
|
342 { |
|
343 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESESSIONERROR_ENTRY); |
|
344 |
|
345 OstTrace1( |
|
346 TRACE_NORMAL, |
|
347 WLANLOGINENGINE_SESSION_ERROR_TRACE, |
|
348 "WlanLoginEngine::handleSessionError;error=%d", |
|
349 error); |
|
350 |
|
351 switch (engineState()) { |
|
352 case OpeningNetworkSession: |
|
353 showConnectionDroppedMessageBox(); |
|
354 break; |
|
355 |
|
356 case NetworkSessionOpened: |
|
357 case IctsRan: |
|
358 if (error == QNetworkSession::SessionAbortedError ) { |
|
359 showConnectionDroppedMessageBox(); |
|
360 } |
|
361 break; |
|
362 |
|
363 case RunningIcts: |
|
364 if (error == QNetworkSession::SessionAbortedError ) { |
|
365 stopIcts(); |
|
366 showConnectionDroppedMessageBox(); |
|
367 } |
|
368 break; |
|
369 |
|
370 default: |
|
371 break; |
|
372 } |
|
373 |
|
374 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESESSIONERROR_EXIT); |
|
375 } |
|
376 |
|
377 /*! |
|
378 This function handles startIcts signal and starts connectivity test in polling mode |
|
379 |
|
380 */ |
|
381 void WlanLoginEngine::handleStartIcts() |
|
382 { |
|
383 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLESTARTICTS_ENTRY); |
|
384 |
|
385 if (!mIctsWrapper->isPolling()) { |
|
386 setEngineState(RunningIcts); |
|
387 mIctsWrapper->startPolling(totalPollingTime, pollingInterval); |
|
388 } |
|
389 |
|
390 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLESTARTICTS_EXIT); |
|
391 } |
|
392 |
|
393 /*! |
|
394 This function stops internet connectivity test |
|
395 |
|
396 */ |
|
397 void WlanLoginEngine::stopIcts() |
|
398 { |
|
399 OstTraceFunctionEntry0(WLANLOGINENGINE_STOPICTS_ENTRY); |
|
400 |
|
401 if (mIctsWrapper->isPolling()) { |
|
402 mIctsWrapper->stopPolling(); |
|
403 } |
|
404 |
|
405 OstTraceFunctionExit0(WLANLOGINENGINE_STOPICTS_EXIT); |
|
406 } |
|
407 |
|
408 /*! |
|
409 This slot handles connectivityTestResult signal from ICTS wrapper |
|
410 @param [in] result Result of the internet connectivity test |
|
411 @param [in] redirectionUrl The URL that we are being redirected, valid only if result is HttpAuthenticationNeeded |
|
412 */ |
|
413 |
|
414 void WlanLoginEngine::handleConnectivityTestResult(IctsWrapper::ConnectivityTestResult result, QUrl redirectUrl) |
|
415 { |
|
416 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLECONNECTIVITYTESTRESULT_ENTRY); |
|
417 |
|
418 Q_UNUSED(redirectUrl); |
|
419 |
|
420 setEngineState(IctsRan); |
|
421 mIctsFirstRun = false; |
|
422 |
|
423 if (result == IctsWrapper::ConnectionOk){ |
|
424 emit ictsOk(); |
|
425 } |
|
426 |
|
427 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLECONNECTIVITYTESTRESULT_EXIT); |
|
428 } |
|
429 |
|
430 /*! |
|
431 This slot handles cancelTriggered signal from the view |
|
432 |
|
433 */ |
|
434 void WlanLoginEngine::handleCancelTriggered() |
|
435 { |
|
436 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLECANCELTRIGGERED_ENTRY); |
|
437 |
|
438 //Stop ICTS if it is running: |
|
439 if (engineState() == RunningIcts) { |
|
440 stopIcts(); |
|
441 if (mIctsFirstRun) { |
|
442 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusCancel); |
|
443 } else { |
|
444 //Previous ICTS must have failed as cancel action can't be selected from UI if |
|
445 //it has passed |
|
446 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusFailed); |
|
447 } |
|
448 } else if (engineState() == IctsRan) { |
|
449 //ICTS must have failed as cancel action can't be selected from UI if |
|
450 //it has passed |
|
451 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusFailed); |
|
452 } else { |
|
453 //ICTS not run yet |
|
454 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusCancel); |
|
455 } |
|
456 |
|
457 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLECANCELTRIGGERED_EXIT); |
|
458 } |
|
459 |
|
460 /*! |
|
461 This slot handles nextTriggered signal from the view |
|
462 |
|
463 */ |
|
464 void WlanLoginEngine::handleNextTriggered() |
|
465 { |
|
466 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLENEXTTRIGGERED_ENTRY); |
|
467 |
|
468 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusNext); |
|
469 |
|
470 //put application to background: |
|
471 WlanLoginApplication* app = static_cast<WlanLoginApplication *>(this->parent()); |
|
472 app->mainWindow()->lower(); |
|
473 |
|
474 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLENEXTTRIGGERED_EXIT); |
|
475 } |
|
476 |
|
477 /*! |
|
478 This slot handles continueTriggered signal from the view |
|
479 |
|
480 */ |
|
481 void WlanLoginEngine::handleContinueTriggered() |
|
482 { |
|
483 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLECONTINUETRIGGERED_ENTRY); |
|
484 |
|
485 //put application to background: |
|
486 WlanLoginApplication* app = static_cast<WlanLoginApplication *>(this->parent()); |
|
487 app->mainWindow()->lower(); |
|
488 |
|
489 OstTraceFunctionExit0(WLANLOGINENGINE_HANDLECONTINUETRIGGERED_EXIT); |
|
490 } |
|
491 |
|
492 /*! |
|
493 This function shows connection dropped message box to the user |
|
494 |
|
495 */ |
|
496 void WlanLoginEngine::showConnectionDroppedMessageBox() |
|
497 { |
|
498 OstTraceFunctionEntry0(WLANLOGINENGINE_SHOWCONNECTIONDROPPEDMESSAGEBOX_ENTRY); |
|
499 |
|
500 HbMessageBox *messageBox = new HbMessageBox(hbTrId("txt_occ_info_wlan_connection_closed_login_applica")); |
|
501 messageBox->setAttribute(Qt::WA_DeleteOnClose); |
|
502 messageBox->setTimeout(messageBoxTimeout); |
|
503 messageBox->open(this,SLOT(connectionDroppedMessageBoxClosed(HbAction*))); |
|
504 |
|
505 OstTraceFunctionExit0(WLANLOGINENGINE_SHOWCONNECTIONDROPPEDMESSAGEBOX_EXIT); |
|
506 } |
|
507 |
|
508 void WlanLoginEngine::connectionDroppedMessageBoxClosed(HbAction* action) |
|
509 { |
|
510 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLEMESSAGEBOXCLOSED_ENTRY); |
|
511 |
|
512 Q_UNUSED(action); |
|
513 |
|
514 if (mServiceRequestCompleted == false ) { |
|
515 emitCompleteServiceRequest(WlanLoginService::WlanLoginStatusConnectionDropped); |
|
516 |
|
517 } else { |
|
518 //If Qt Highway service request is already completed when connection drops, we have to make exit by our own |
|
519 qApp->exit(); |
|
520 } |
|
521 |
|
522 OstTraceFunctionEntry0(WLANLOGINENGINE_HANDLEMESSAGEBOXCLOSED_EXIT); |
|
523 } |
|
524 |
|
525 /*! |
|
526 This function completes Qt Highway service request |
|
527 @param [in] status completeing status of the service request |
|
528 */ |
|
529 void WlanLoginEngine::emitCompleteServiceRequest(WlanLoginService::WlanLoginStatus status ) |
|
530 { |
|
531 OstTraceFunctionEntry0(WLANLOGINENGINE_EMITCOMPLETESERVICEREQUEST_ENTRY); |
|
532 |
|
533 mServiceRequestCompleted = true; |
|
534 OstTrace1( |
|
535 TRACE_BORDER, |
|
536 WLANLOGINENGINE_EMITCOMPLETESERVICEREQUEST_EMIT_TRACE, |
|
537 "WlanLoginEngine::emitCompleteServiceRequest with status:;status=%d", |
|
538 status); |
|
539 emit completeServiceRequest(status); |
|
540 |
|
541 OstTraceFunctionExit0(WLANLOGINENGINE_EMITCOMPLETESERVICEREQUEST_EXIT); |
|
542 } |